Module: Tensorflow::RawOps

Defined in:
lib/tensorflow/ops/raw_ops.rb

Class Method Summary collapse

Class Method Details

._arg(typeT: nil, index: nil, name: "_Arg") ⇒ Object 



5011
5012
5013
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5011

def self._arg(typeT: nil, index: nil, name: "_Arg")
  self.execute("_Arg", [], T: typeT, index: index, name: name)
end

._array_to_list(input, typeT: nil, n: nil, out_types: nil, name: "_ArrayToList") ⇒ Object 



5015
5016
5017
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5015

def self._array_to_list(input, typeT: nil, n: nil, out_types: nil, name: "_ArrayToList")
  self.execute("_ArrayToList", [input], T: typeT, N: n, out_types: out_types, name: name)
end

._configure_distributed_tpu(inputs, n: nil, enable_whole_mesh_compilations: false, name: "_ConfigureDistributedTPU") ⇒ Object 



5019
5020
5021
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5019

def self._configure_distributed_tpu(inputs, n: nil, enable_whole_mesh_compilations: false, name: "_ConfigureDistributedTPU")
  self.execute("_ConfigureDistributedTPU", [inputs], N: n, enable_whole_mesh_compilations: enable_whole_mesh_compilations, name: name)
end

._device_arg(typeT: nil, index: nil, name: "_DeviceArg") ⇒ Object 



5023
5024
5025
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5023

def self._device_arg(typeT: nil, index: nil, name: "_DeviceArg")
  self.execute("_DeviceArg", [], T: typeT, index: index, name: name)
end

._device_retval(input, typeT: nil, index: nil, name: "_DeviceRetval") ⇒ Object 



5027
5028
5029
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5027

def self._device_retval(input, typeT: nil, index: nil, name: "_DeviceRetval")
  self.execute("_DeviceRetval", [input], T: typeT, index: index, name: name)
end

._disconnect_host_from_distributed_tpu_system(name: "_DisconnectHostFromDistributedTPUSystem") ⇒ Object 



5031
5032
5033
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5031

def self._disconnect_host_from_distributed_tpu_system(name: "_DisconnectHostFromDistributedTPUSystem")
  self.execute("_DisconnectHostFromDistributedTPUSystem", [], name: name)
end

._fused_batch_norm_ex(x, scale, offset, mean, variance, side_input, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, num_side_inputs: 0, activation_mode: "Identity", data_format: "NHWC", is_training: true, name: "_FusedBatchNormEx") ⇒ Object 



5035
5036
5037
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5035

def self._fused_batch_norm_ex(x, scale, offset, mean, variance, side_input, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, num_side_inputs: 0, activation_mode: "Identity", data_format: "NHWC", is_training: true, name: "_FusedBatchNormEx")
  self.execute("_FusedBatchNormEx", [x, scale, offset, mean, variance, side_input], T: typeT, U: u, epsilon: epsilon, num_side_inputs: num_side_inputs, activation_mode: activation_mode, data_format: data_format, is_training: is_training, name: name)
end

._fused_conv2_d(input, filter, args, typeT: nil, num_args: nil, strides: nil, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], use_cudnn_on_gpu: true, fused_ops: [], epsilon: 9.999999747378752e-05, name: "_FusedConv2D") ⇒ Object 



5039
5040
5041
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5039

def self._fused_conv2_d(input, filter, args, typeT: nil, num_args: nil, strides: nil, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], use_cudnn_on_gpu: true, fused_ops: [], epsilon: 9.999999747378752e-05, name: "_FusedConv2D")
  self.execute("_FusedConv2D", [input, filter, args], T: typeT, num_args: num_args, strides: strides, padding: padding, explicit_paddings: explicit_paddings, data_format: data_format, dilations: dilations, use_cudnn_on_gpu: use_cudnn_on_gpu, fused_ops: fused_ops, epsilon: epsilon, name: name)
end

._fused_mat_mul(a, b, args, transpose_a: false, transpose_b: false, typeT: nil, num_args: nil, fused_ops: [], epsilon: 9.999999747378752e-05, name: "_FusedMatMul") ⇒ Object 



5043
5044
5045
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5043

def self._fused_mat_mul(a, b, args, transpose_a: false, transpose_b: false, typeT: nil, num_args: nil, fused_ops: [], epsilon: 9.999999747378752e-05, name: "_FusedMatMul")
  self.execute("_FusedMatMul", [a, b, args], transpose_a: transpose_a, transpose_b: transpose_b, T: typeT, num_args: num_args, fused_ops: fused_ops, epsilon: epsilon, name: name)
end

._host_cast(x, srct: nil, dstt: nil, truncate: false, name: "_HostCast") ⇒ Object 



5047
5048
5049
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5047

def self._host_cast(x, srct: nil, dstt: nil, truncate: false, name: "_HostCast")
  self.execute("_HostCast", [x], SrcT: srct, DstT: dstt, Truncate: truncate, name: name)
end

._host_recv(tensor_type: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_HostRecv") ⇒ Object 



5051
5052
5053
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5051

def self._host_recv(tensor_type: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_HostRecv")
  self.execute("_HostRecv", [], tensor_type: tensor_type, tensor_name: tensor_name, send_device: send_device, send_device_incarnation: send_device_incarnation, recv_device: recv_device, client_terminated: client_terminated, name: name)
end

._host_send(tensor, typeT: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_HostSend") ⇒ Object 



5055
5056
5057
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5055

def self._host_send(tensor, typeT: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_HostSend")
  self.execute("_HostSend", [tensor], T: typeT, tensor_name: tensor_name, send_device: send_device, send_device_incarnation: send_device_incarnation, recv_device: recv_device, client_terminated: client_terminated, name: name)
end

._if(cond, input, tcond: nil, tin: nil, tout: nil, then_branch: nil, else_branch: nil, name: "_If") ⇒ Object 



5059
5060
5061
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5059

def self._if(cond, input, tcond: nil, tin: nil, tout: nil, then_branch: nil, else_branch: nil, name: "_If")
  self.execute("_If", [cond, input], Tcond: tcond, Tin: tin, Tout: tout, then_branch: then_branch, else_branch: else_branch, name: name)
end

._initialize_host_for_distributed_tpu(input, enable_whole_mesh_compilations: false, name: "_InitializeHostForDistributedTPU") ⇒ Object 



5063
5064
5065
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5063

def self._initialize_host_for_distributed_tpu(input, enable_whole_mesh_compilations: false, name: "_InitializeHostForDistributedTPU")
  self.execute("_InitializeHostForDistributedTPU", [input], enable_whole_mesh_compilations: enable_whole_mesh_compilations, name: name)
end

._list_to_array(input, tin: nil, typeT: nil, n: nil, name: "_ListToArray") ⇒ Object 



5067
5068
5069
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5067

def self._list_to_array(input, tin: nil, typeT: nil, n: nil, name: "_ListToArray")
  self.execute("_ListToArray", [input], Tin: tin, T: typeT, N: n, name: name)
end

._mkl_maximum(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklMaximum") ⇒ Object 



5071
5072
5073
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5071

def self._mkl_maximum(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklMaximum")
  self.execute("_MklMaximum", [x, y, mkl_x, mkl_y], T: typeT, name: name)
end

._mkl_mul(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklMul") ⇒ Object 



5075
5076
5077
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5075

def self._mkl_mul(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklMul")
  self.execute("_MklMul", [x, y, mkl_x, mkl_y], T: typeT, name: name)
end

._mkl_squared_difference(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklSquaredDifference") ⇒ Object 



5079
5080
5081
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5079

def self._mkl_squared_difference(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklSquaredDifference")
  self.execute("_MklSquaredDifference", [x, y, mkl_x, mkl_y], T: typeT, name: name)
end

._mkl_sub(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklSub") ⇒ Object 



5083
5084
5085
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5083

def self._mkl_sub(x, y, mkl_x, mkl_y, typeT: nil, name: "_MklSub")
  self.execute("_MklSub", [x, y, mkl_x, mkl_y], T: typeT, name: name)
end

._nccl_broadcast_recv(shape, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclBroadcastRecv") ⇒ Object 



5087
5088
5089
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5087

def self._nccl_broadcast_recv(shape, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclBroadcastRecv")
  self.execute("_NcclBroadcastRecv", [shape], T: typeT, num_devices: num_devices, shared_name: shared_name, name: name)
end

._nccl_broadcast_send(input, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclBroadcastSend") ⇒ Object 



5091
5092
5093
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5091

def self._nccl_broadcast_send(input, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclBroadcastSend")
  self.execute("_NcclBroadcastSend", [input], T: typeT, num_devices: num_devices, shared_name: shared_name, name: name)
end

._nccl_reduce_recv(input, reduction: nil, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclReduceRecv") ⇒ Object 



5095
5096
5097
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5095

def self._nccl_reduce_recv(input, reduction: nil, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclReduceRecv")
  self.execute("_NcclReduceRecv", [input], reduction: reduction, T: typeT, num_devices: num_devices, shared_name: shared_name, name: name)
end

._nccl_reduce_send(input, reduction: nil, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclReduceSend") ⇒ Object 



5099
5100
5101
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5099

def self._nccl_reduce_send(input, reduction: nil, typeT: nil, num_devices: nil, shared_name: "", name: "_NcclReduceSend")
  self.execute("_NcclReduceSend", [input], reduction: reduction, T: typeT, num_devices: num_devices, shared_name: shared_name, name: name)
end

._parallel_concat_start(shape: nil, dtype: nil, name: "_ParallelConcatStart") ⇒ Object 



5103
5104
5105
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5103

def self._parallel_concat_start(shape: nil, dtype: nil, name: "_ParallelConcatStart")
  self.execute("_ParallelConcatStart", [], shape: shape, dtype: dtype, name: name)
end

._parallel_concat_update(value, update, typeT: nil, loc: nil, name: "_ParallelConcatUpdate") ⇒ Object 



5107
5108
5109
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5107

def self._parallel_concat_update(value, update, typeT: nil, loc: nil, name: "_ParallelConcatUpdate")
  self.execute("_ParallelConcatUpdate", [value, update], T: typeT, loc: loc, name: name)
end

._read_variables_op(resources, n: nil, dtypes: nil, name: "_ReadVariablesOp") ⇒ Object 



5111
5112
5113
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5111

def self._read_variables_op(resources, n: nil, dtypes: nil, name: "_ReadVariablesOp")
  self.execute("_ReadVariablesOp", [resources], N: n, dtypes: dtypes, name: name)
end

._recv(tensor_type: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_Recv") ⇒ Object 



5115
5116
5117
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5115

def self._recv(tensor_type: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_Recv")
  self.execute("_Recv", [], tensor_type: tensor_type, tensor_name: tensor_name, send_device: send_device, send_device_incarnation: send_device_incarnation, recv_device: recv_device, client_terminated: client_terminated, name: name)
end

._retval(input, typeT: nil, index: nil, name: "_Retval") ⇒ Object 



5119
5120
5121
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5119

def self._retval(input, typeT: nil, index: nil, name: "_Retval")
  self.execute("_Retval", [input], T: typeT, index: index, name: name)
end

._scoped_allocator(shapes: nil, shape: nil, typeT: nil, sa_name: "", id: nil, expected_call_count: nil, name: "_ScopedAllocator") ⇒ Object 



5123
5124
5125
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5123

def self._scoped_allocator(shapes: nil, shape: nil, typeT: nil, sa_name: "", id: nil, expected_call_count: nil, name: "_ScopedAllocator")
  self.execute("_ScopedAllocator", [], shapes: shapes, shape: shape, T: typeT, sa_name: sa_name, id: id, expected_call_count: expected_call_count, name: name)
end

._scoped_allocator_concat(backing, inputs, shape: nil, typeT: nil, reshape: false, sa_name: "", id: nil, n: nil, name: "_ScopedAllocatorConcat") ⇒ Object 



5127
5128
5129
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5127

def self._scoped_allocator_concat(backing, inputs, shape: nil, typeT: nil, reshape: false, sa_name: "", id: nil, n: nil, name: "_ScopedAllocatorConcat")
  self.execute("_ScopedAllocatorConcat", [backing, inputs], shape: shape, T: typeT, reshape: reshape, sa_name: sa_name, id: id, N: n, name: name)
end

._scoped_allocator_split(concat, split, typeT: nil, sa_name: "", id: nil, n: nil, shapes: nil, name: "_ScopedAllocatorSplit") ⇒ Object 



5131
5132
5133
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5131

def self._scoped_allocator_split(concat, split, typeT: nil, sa_name: "", id: nil, n: nil, shapes: nil, name: "_ScopedAllocatorSplit")
  self.execute("_ScopedAllocatorSplit", [concat, split], T: typeT, sa_name: sa_name, id: id, N: n, shapes: shapes, name: name)
end

._send(tensor, typeT: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_Send") ⇒ Object 



5135
5136
5137
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5135

def self._send(tensor, typeT: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "_Send")
  self.execute("_Send", [tensor], T: typeT, tensor_name: tensor_name, send_device: send_device, send_device_incarnation: send_device_incarnation, recv_device: recv_device, client_terminated: client_terminated, name: name)
end

._set_global_tpu_array(topology, name: "_SetGlobalTPUArray") ⇒ Object 



5139
5140
5141
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5139

def self._set_global_tpu_array(topology, name: "_SetGlobalTPUArray")
  self.execute("_SetGlobalTPUArray", [topology], name: name)
end

._shutdown_distributed_tpu(name: "_ShutdownDistributedTPU") ⇒ Object 



5143
5144
5145
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5143

def self._shutdown_distributed_tpu(name: "_ShutdownDistributedTPU")
  self.execute("_ShutdownDistributedTPU", [], name: name)
end

._switch_n(data, output_index, num_outs: nil, typeT: nil, name: "_SwitchN") ⇒ Object 



5147
5148
5149
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5147

def self._switch_n(data, output_index, num_outs: nil, typeT: nil, name: "_SwitchN")
  self.execute("_SwitchN", [data, output_index], num_outs: num_outs, T: typeT, name: name)
end

._tpu_replicate(inputs, broadcast_inputs, variables, guaranteed_constants, computation: nil, num_replicas: nil, num_cores_per_replica: 1, topology: "", use_tpu: true, device_assignment: [], host_compute_core: [], tinputs: nil, tbroadcast_inputs: nil, numvariables: nil, tguaranteed_constants: nil, output_types: nil, padding_map: [], step_marker_location: "STEP_MARK_AT_ENTRY", allow_soft_placement: false, name: "_TPUReplicate") ⇒ Object 



5151
5152
5153
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5151

def self._tpu_replicate(inputs, broadcast_inputs, variables, guaranteed_constants, computation: nil, num_replicas: nil, num_cores_per_replica: 1, topology: "", use_tpu: true, device_assignment: [], host_compute_core: [], tinputs: nil, tbroadcast_inputs: nil, numvariables: nil, tguaranteed_constants: nil, output_types: nil, padding_map: [], step_marker_location: "STEP_MARK_AT_ENTRY", allow_soft_placement: false, name: "_TPUReplicate")
  self.execute("_TPUReplicate", [inputs, broadcast_inputs, variables, guaranteed_constants], computation: computation, num_replicas: num_replicas, num_cores_per_replica: num_cores_per_replica, topology: topology, use_tpu: use_tpu, device_assignment: device_assignment, host_compute_core: host_compute_core, Tinputs: tinputs, Tbroadcast_inputs: tbroadcast_inputs, NumVariables: numvariables, Tguaranteed_constants: tguaranteed_constants, output_types: output_types, padding_map: padding_map, step_marker_location: step_marker_location, allow_soft_placement: allow_soft_placement, name: name)
end

._unary_ops_composition(x, typeT: nil, op_names: nil, name: "_UnaryOpsComposition") ⇒ Object 



5155
5156
5157
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5155

def self._unary_ops_composition(x, typeT: nil, op_names: nil, name: "_UnaryOpsComposition")
  self.execute("_UnaryOpsComposition", [x], T: typeT, op_names: op_names, name: name)
end

._var_handles_op(containers: nil, shared_names: nil, n: nil, dtypes: nil, shapes: nil, name: "_VarHandlesOp") ⇒ Object 



5159
5160
5161
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5159

def self._var_handles_op(containers: nil, shared_names: nil, n: nil, dtypes: nil, shapes: nil, name: "_VarHandlesOp")
  self.execute("_VarHandlesOp", [], containers: containers, shared_names: shared_names, N: n, dtypes: dtypes, shapes: shapes, name: name)
end

._wait_for_distributed_tpu(inputs, startup_timeout_sec: 20, n: nil, name: "_WaitForDistributedTPU") ⇒ Object 



5163
5164
5165
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5163

def self._wait_for_distributed_tpu(inputs, startup_timeout_sec: 20, n: nil, name: "_WaitForDistributedTPU")
  self.execute("_WaitForDistributedTPU", [inputs], startup_timeout_sec: startup_timeout_sec, N: n, name: name)
end

._while(input, typeT: nil, cond: nil, body: nil, name: "_While") ⇒ Object 



5167
5168
5169
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5167

def self._while(input, typeT: nil, cond: nil, body: nil, name: "_While")
  self.execute("_While", [input], T: typeT, cond: cond, body: body, name: name)
end

._xla_recv_at_host(dynamic_key, toutputs: nil, key: "", device_ordinal: nil, name: "_XlaRecvAtHost") ⇒ Object 



5171
5172
5173
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5171

def self._xla_recv_at_host(dynamic_key, toutputs: nil, key: "", device_ordinal: nil, name: "_XlaRecvAtHost")
  self.execute("_XlaRecvAtHost", [dynamic_key], Toutputs: toutputs, key: key, device_ordinal: device_ordinal, name: name)
end

._xla_send_from_host(inputs, dynamic_key, tinputs: nil, key: "", device_ordinal: nil, name: "_XlaSendFromHost") ⇒ Object 



5175
5176
5177
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5175

def self._xla_send_from_host(inputs, dynamic_key, tinputs: nil, key: "", device_ordinal: nil, name: "_XlaSendFromHost")
  self.execute("_XlaSendFromHost", [inputs, dynamic_key], Tinputs: tinputs, key: key, device_ordinal: device_ordinal, name: name)
end

.abort(error_msg: "", exit_without_error: false, name: "Abort") ⇒ Object 



18
19
20
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 18

def self.abort(error_msg: "", exit_without_error: false, name: "Abort")
  self.execute("Abort", [], error_msg: error_msg, exit_without_error: exit_without_error, name: name)
end

.abs(x, typeT: nil, name: "Abs") ⇒ Object 



22
23
24
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 22

def self.abs(x, typeT: nil, name: "Abs")
  self.execute("Abs", [x], T: typeT, name: name)
end

.accumulate_nv2(inputs, n: nil, typeT: nil, shape: nil, name: "AccumulateNV2") ⇒ Object 



26
27
28
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 26

def self.accumulate_nv2(inputs, n: nil, typeT: nil, shape: nil, name: "AccumulateNV2")
  self.execute("AccumulateNV2", [inputs], N: n, T: typeT, shape: shape, name: name)
end

.accumulator_apply_gradient(handle, local_step, gradient, dtype: nil, name: "AccumulatorApplyGradient") ⇒ Object 



30
31
32
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 30

def self.accumulator_apply_gradient(handle, local_step, gradient, dtype: nil, name: "AccumulatorApplyGradient")
  self.execute("AccumulatorApplyGradient", [handle, local_step, gradient], dtype: dtype, name: name)
end

.accumulator_num_accumulated(handle, name: "AccumulatorNumAccumulated") ⇒ Object 



34
35
36
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 34

def self.accumulator_num_accumulated(handle, name: "AccumulatorNumAccumulated")
  self.execute("AccumulatorNumAccumulated", [handle], name: name)
end

.accumulator_set_global_step(handle, new_global_step, name: "AccumulatorSetGlobalStep") ⇒ Object 



38
39
40
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 38

def self.accumulator_set_global_step(handle, new_global_step, name: "AccumulatorSetGlobalStep")
  self.execute("AccumulatorSetGlobalStep", [handle, new_global_step], name: name)
end

.accumulator_take_gradient(handle, num_required, dtype: nil, name: "AccumulatorTakeGradient") ⇒ Object 



42
43
44
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 42

def self.accumulator_take_gradient(handle, num_required, dtype: nil, name: "AccumulatorTakeGradient")
  self.execute("AccumulatorTakeGradient", [handle, num_required], dtype: dtype, name: name)
end

.acos(x, typeT: nil, name: "Acos") ⇒ Object 



46
47
48
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 46

def self.acos(x, typeT: nil, name: "Acos")
  self.execute("Acos", [x], T: typeT, name: name)
end

.acosh(x, typeT: nil, name: "Acosh") ⇒ Object 



50
51
52
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 50

def self.acosh(x, typeT: nil, name: "Acosh")
  self.execute("Acosh", [x], T: typeT, name: name)
end

.add(x, y, typeT: nil, name: "Add") ⇒ Object 



54
55
56
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 54

def self.add(x, y, typeT: nil, name: "Add")
  self.execute("Add", [x, y], T: typeT, name: name)
end

.add_many_sparse_to_tensors_map(sparse_indices, sparse_values, sparse_shape, typeT: nil, container: "", shared_name: "", name: "AddManySparseToTensorsMap") ⇒ Object 



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

def self.add_many_sparse_to_tensors_map(sparse_indices, sparse_values, sparse_shape, typeT: nil, container: "", shared_name: "", name: "AddManySparseToTensorsMap")
  self.execute("AddManySparseToTensorsMap", [sparse_indices, sparse_values, sparse_shape], T: typeT, container: container, shared_name: shared_name, name: name)
end

.add_n(inputs, n: nil, typeT: nil, name: "AddN") ⇒ Object 



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

def self.add_n(inputs, n: nil, typeT: nil, name: "AddN")
  self.execute("AddN", [inputs], N: n, T: typeT, name: name)
end

.add_sparse_to_tensors_map(sparse_indices, sparse_values, sparse_shape, typeT: nil, container: "", shared_name: "", name: "AddSparseToTensorsMap") ⇒ Object 



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

def self.add_sparse_to_tensors_map(sparse_indices, sparse_values, sparse_shape, typeT: nil, container: "", shared_name: "", name: "AddSparseToTensorsMap")
  self.execute("AddSparseToTensorsMap", [sparse_indices, sparse_values, sparse_shape], T: typeT, container: container, shared_name: shared_name, name: name)
end

.add_v2(x, y, typeT: nil, name: "AddV2") ⇒ Object 



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

def self.add_v2(x, y, typeT: nil, name: "AddV2")
  self.execute("AddV2", [x, y], T: typeT, name: name)
end

.adjust_contrast(images, contrast_factor, min_value, max_value, typeT: nil, name: "AdjustContrast") ⇒ Object 



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

def self.adjust_contrast(images, contrast_factor, min_value, max_value, typeT: nil, name: "AdjustContrast")
  self.execute("AdjustContrast", [images, contrast_factor, min_value, max_value], T: typeT, name: name)
end

.adjust_contrastv2(images, contrast_factor, typeT: :float, name: "AdjustContrastv2") ⇒ Object 



78
79
80
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 78

def self.adjust_contrastv2(images, contrast_factor, typeT: :float, name: "AdjustContrastv2")
  self.execute("AdjustContrastv2", [images, contrast_factor], T: typeT, name: name)
end

.adjust_hue(images, delta, typeT: :float, name: "AdjustHue") ⇒ Object 



82
83
84
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 82

def self.adjust_hue(images, delta, typeT: :float, name: "AdjustHue")
  self.execute("AdjustHue", [images, delta], T: typeT, name: name)
end

.adjust_saturation(images, scale, typeT: :float, name: "AdjustSaturation") ⇒ Object 



86
87
88
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 86

def self.adjust_saturation(images, scale, typeT: :float, name: "AdjustSaturation")
  self.execute("AdjustSaturation", [images, scale], T: typeT, name: name)
end

.all(input, reduction_indices, keep_dims: false, tidx: :int32, name: "All") ⇒ Object 



90
91
92
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 90

def self.all(input, reduction_indices, keep_dims: false, tidx: :int32, name: "All")
  self.execute("All", [input, reduction_indices], keep_dims: keep_dims, Tidx: tidx, name: name)
end

.all_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, seed: 0, seed2: 0, name: "AllCandidateSampler") ⇒ Object 



94
95
96
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 94

def self.all_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, seed: 0, seed2: 0, name: "AllCandidateSampler")
  self.execute("AllCandidateSampler", [true_classes], num_true: num_true, num_sampled: num_sampled, unique: unique, seed: seed, seed2: seed2, name: name)
end

.all_to_all(input, group_assignment, typeT: nil, concat_dimension: nil, split_dimension: nil, split_count: nil, name: "AllToAll") ⇒ Object 



98
99
100
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 98

def self.all_to_all(input, group_assignment, typeT: nil, concat_dimension: nil, split_dimension: nil, split_count: nil, name: "AllToAll")
  self.execute("AllToAll", [input, group_assignment], T: typeT, concat_dimension: concat_dimension, split_dimension: split_dimension, split_count: split_count, name: name)
end

.angle(input, typeT: :complex64, tout: :float, name: "Angle") ⇒ Object 



102
103
104
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 102

def self.angle(input, typeT: :complex64, tout: :float, name: "Angle")
  self.execute("Angle", [input], T: typeT, Tout: tout, name: name)
end

.anonymous_iterator(output_types: nil, output_shapes: nil, name: "AnonymousIterator") ⇒ Object 



106
107
108
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 106

def self.anonymous_iterator(output_types: nil, output_shapes: nil, name: "AnonymousIterator")
  self.execute("AnonymousIterator", [], output_types: output_types, output_shapes: output_shapes, name: name)
end

.anonymous_iterator_v2(output_types: nil, output_shapes: nil, name: "AnonymousIteratorV2") ⇒ Object 



110
111
112
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 110

def self.anonymous_iterator_v2(output_types: nil, output_shapes: nil, name: "AnonymousIteratorV2")
  self.execute("AnonymousIteratorV2", [], output_types: output_types, output_shapes: output_shapes, name: name)
end

.anonymous_memory_cache(name: "AnonymousMemoryCache") ⇒ Object 



114
115
116
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 114

def self.anonymous_memory_cache(name: "AnonymousMemoryCache")
  self.execute("AnonymousMemoryCache", [], name: name)
end

.anonymous_multi_device_iterator(devices: nil, output_types: nil, output_shapes: nil, name: "AnonymousMultiDeviceIterator") ⇒ Object 



118
119
120
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 118

def self.anonymous_multi_device_iterator(devices: nil, output_types: nil, output_shapes: nil, name: "AnonymousMultiDeviceIterator")
  self.execute("AnonymousMultiDeviceIterator", [], devices: devices, output_types: output_types, output_shapes: output_shapes, name: name)
end

.anonymous_random_seed_generator(seed, seed2, name: "AnonymousRandomSeedGenerator") ⇒ Object 



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

def self.anonymous_random_seed_generator(seed, seed2, name: "AnonymousRandomSeedGenerator")
  self.execute("AnonymousRandomSeedGenerator", [seed, seed2], name: name)
end

.any(input, reduction_indices, keep_dims: false, tidx: :int32, name: "Any") ⇒ Object 



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

def self.any(input, reduction_indices, keep_dims: false, tidx: :int32, name: "Any")
  self.execute("Any", [input, reduction_indices], keep_dims: keep_dims, Tidx: tidx, name: name)
end

.apply_ada_max(var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyAdaMax") ⇒ Object 



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

def self.apply_ada_max(var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyAdaMax")
  self.execute("ApplyAdaMax", [var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyAdadelta") ⇒ Object 



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

def self.apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyAdadelta")
  self.execute("ApplyAdadelta", [var, accum, accum_update, lr, rho, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.apply_adagrad(var, accum, lr, grad, typeT: nil, use_locking: false, update_slots: true, name: "ApplyAdagrad") ⇒ Object 



138
139
140
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 138

def self.apply_adagrad(var, accum, lr, grad, typeT: nil, use_locking: false, update_slots: true, name: "ApplyAdagrad")
  self.execute("ApplyAdagrad", [var, accum, lr, grad], T: typeT, use_locking: use_locking, update_slots: update_slots, name: name)
end

.apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step, typeT: nil, use_locking: false, name: "ApplyAdagradDA") ⇒ Object 



142
143
144
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 142

def self.apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step, typeT: nil, use_locking: false, name: "ApplyAdagradDA")
  self.execute("ApplyAdagradDA", [var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step], T: typeT, use_locking: use_locking, name: name)
end

.apply_adagrad_v2(var, accum, lr, epsilon, grad, typeT: nil, use_locking: false, update_slots: true, name: "ApplyAdagradV2") ⇒ Object 



146
147
148
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 146

def self.apply_adagrad_v2(var, accum, lr, epsilon, grad, typeT: nil, use_locking: false, update_slots: true, name: "ApplyAdagradV2")
  self.execute("ApplyAdagradV2", [var, accum, lr, epsilon, grad], T: typeT, use_locking: use_locking, update_slots: update_slots, name: name)
end

.apply_adam(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, use_nesterov: false, name: "ApplyAdam") ⇒ Object 



150
151
152
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 150

def self.apply_adam(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, use_nesterov: false, name: "ApplyAdam")
  self.execute("ApplyAdam", [var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad], T: typeT, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.apply_add_sign(var, m, lr, alpha, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ApplyAddSign") ⇒ Object 



154
155
156
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 154

def self.apply_add_sign(var, m, lr, alpha, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ApplyAddSign")
  self.execute("ApplyAddSign", [var, m, lr, alpha, sign_decay, beta, grad], T: typeT, use_locking: use_locking, name: name)
end

.apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyCenteredRMSProp") ⇒ Object 



158
159
160
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 158

def self.apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyCenteredRMSProp")
  self.execute("ApplyCenteredRMSProp", [var, mg, ms, mom, lr, rho, momentum, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.apply_ftrl(var, accum, linear, grad, lr, l1, l2, lr_power, typeT: nil, use_locking: false, name: "ApplyFtrl") ⇒ Object 



162
163
164
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 162

def self.apply_ftrl(var, accum, linear, grad, lr, l1, l2, lr_power, typeT: nil, use_locking: false, name: "ApplyFtrl")
  self.execute("ApplyFtrl", [var, accum, linear, grad, lr, l1, l2, lr_power], T: typeT, use_locking: use_locking, name: name)
end

.apply_ftrl_v2(var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, use_locking: false, name: "ApplyFtrlV2") ⇒ Object 



166
167
168
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 166

def self.apply_ftrl_v2(var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, use_locking: false, name: "ApplyFtrlV2")
  self.execute("ApplyFtrlV2", [var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power], T: typeT, use_locking: use_locking, name: name)
end

.apply_gradient_descent(var, alpha, delta, typeT: nil, use_locking: false, name: "ApplyGradientDescent") ⇒ Object 



170
171
172
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 170

def self.apply_gradient_descent(var, alpha, delta, typeT: nil, use_locking: false, name: "ApplyGradientDescent")
  self.execute("ApplyGradientDescent", [var, alpha, delta], T: typeT, use_locking: use_locking, name: name)
end

.apply_momentum(var, accum, lr, grad, momentum, typeT: nil, use_locking: false, use_nesterov: false, name: "ApplyMomentum") ⇒ Object 



174
175
176
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 174

def self.apply_momentum(var, accum, lr, grad, momentum, typeT: nil, use_locking: false, use_nesterov: false, name: "ApplyMomentum")
  self.execute("ApplyMomentum", [var, accum, lr, grad, momentum], T: typeT, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.apply_power_sign(var, m, lr, logbase, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ApplyPowerSign") ⇒ Object 



178
179
180
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 178

def self.apply_power_sign(var, m, lr, logbase, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ApplyPowerSign")
  self.execute("ApplyPowerSign", [var, m, lr, logbase, sign_decay, beta, grad], T: typeT, use_locking: use_locking, name: name)
end

.apply_proximal_adagrad(var, accum, lr, l1, l2, grad, typeT: nil, use_locking: false, name: "ApplyProximalAdagrad") ⇒ Object 



182
183
184
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 182

def self.apply_proximal_adagrad(var, accum, lr, l1, l2, grad, typeT: nil, use_locking: false, name: "ApplyProximalAdagrad")
  self.execute("ApplyProximalAdagrad", [var, accum, lr, l1, l2, grad], T: typeT, use_locking: use_locking, name: name)
end

.apply_proximal_gradient_descent(var, alpha, l1, l2, delta, typeT: nil, use_locking: false, name: "ApplyProximalGradientDescent") ⇒ Object 



186
187
188
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 186

def self.apply_proximal_gradient_descent(var, alpha, l1, l2, delta, typeT: nil, use_locking: false, name: "ApplyProximalGradientDescent")
  self.execute("ApplyProximalGradientDescent", [var, alpha, l1, l2, delta], T: typeT, use_locking: use_locking, name: name)
end

.apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyRMSProp") ⇒ Object 



190
191
192
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 190

def self.apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ApplyRMSProp")
  self.execute("ApplyRMSProp", [var, ms, mom, lr, rho, momentum, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.approximate_equal(x, y, typeT: nil, tolerance: 9.999999747378752e-06, name: "ApproximateEqual") ⇒ Object 



194
195
196
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 194

def self.approximate_equal(x, y, typeT: nil, tolerance: 9.999999747378752e-06, name: "ApproximateEqual")
  self.execute("ApproximateEqual", [x, y], T: typeT, tolerance: tolerance, name: name)
end

.arg_max(input, dimension, typeT: nil, tidx: :int32, output_type: :int64, name: "ArgMax") ⇒ Object 



198
199
200
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 198

def self.arg_max(input, dimension, typeT: nil, tidx: :int32, output_type: :int64, name: "ArgMax")
  self.execute("ArgMax", [input, dimension], T: typeT, Tidx: tidx, output_type: output_type, name: name)
end

.arg_min(input, dimension, typeT: nil, tidx: :int32, output_type: :int64, name: "ArgMin") ⇒ Object 



202
203
204
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 202

def self.arg_min(input, dimension, typeT: nil, tidx: :int32, output_type: :int64, name: "ArgMin")
  self.execute("ArgMin", [input, dimension], T: typeT, Tidx: tidx, output_type: output_type, name: name)
end

.as_string(input, typeT: nil, precision: -1,, scientific: false, shortest: false, width: -1,, fill: "", name: "AsString") ⇒ Object 



206
207
208
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 206

def self.as_string(input, typeT: nil, precision: -1, scientific: false, shortest: false, width: -1, fill: "", name: "AsString")
  self.execute("AsString", [input], T: typeT, precision: precision, scientific: scientific, shortest: shortest, width: width, fill: fill, name: name)
end

.asin(x, typeT: nil, name: "Asin") ⇒ Object 



210
211
212
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 210

def self.asin(x, typeT: nil, name: "Asin")
  self.execute("Asin", [x], T: typeT, name: name)
end

.asinh(x, typeT: nil, name: "Asinh") ⇒ Object 



214
215
216
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 214

def self.asinh(x, typeT: nil, name: "Asinh")
  self.execute("Asinh", [x], T: typeT, name: name)
end

.assert(condition, data, typeT: nil, summarize: 3, name: "Assert") ⇒ Object 



218
219
220
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 218

def self.assert(condition, data, typeT: nil, summarize: 3, name: "Assert")
  self.execute("Assert", [condition, data], T: typeT, summarize: summarize, name: name)
end

.assert_next_dataset(input_dataset, transformations, output_types: nil, output_shapes: nil, name: "AssertNextDataset") ⇒ Object 



222
223
224
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 222

def self.assert_next_dataset(input_dataset, transformations, output_types: nil, output_shapes: nil, name: "AssertNextDataset")
  self.execute("AssertNextDataset", [input_dataset, transformations], output_types: output_types, output_shapes: output_shapes, name: name)
end

.assign(ref, value, typeT: nil, validate_shape: true, use_locking: true, name: "Assign") ⇒ Object 



226
227
228
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 226

def self.assign(ref, value, typeT: nil, validate_shape: true, use_locking: true, name: "Assign")
  self.execute("Assign", [ref, value], T: typeT, validate_shape: validate_shape, use_locking: use_locking, name: name)
end

.assign_add(ref, value, typeT: nil, use_locking: false, name: "AssignAdd") ⇒ Object 



230
231
232
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 230

def self.assign_add(ref, value, typeT: nil, use_locking: false, name: "AssignAdd")
  self.execute("AssignAdd", [ref, value], T: typeT, use_locking: use_locking, name: name)
end

.assign_add_variable_op(resource, value, dtype: nil, name: "AssignAddVariableOp") ⇒ Object 



234
235
236
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 234

def self.assign_add_variable_op(resource, value, dtype: nil, name: "AssignAddVariableOp")
  self.execute("AssignAddVariableOp", [resource, value], dtype: dtype, name: name)
end

.assign_sub(ref, value, typeT: nil, use_locking: false, name: "AssignSub") ⇒ Object 



238
239
240
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 238

def self.assign_sub(ref, value, typeT: nil, use_locking: false, name: "AssignSub")
  self.execute("AssignSub", [ref, value], T: typeT, use_locking: use_locking, name: name)
end

.assign_sub_variable_op(resource, value, dtype: nil, name: "AssignSubVariableOp") ⇒ Object 



242
243
244
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 242

def self.assign_sub_variable_op(resource, value, dtype: nil, name: "AssignSubVariableOp")
  self.execute("AssignSubVariableOp", [resource, value], dtype: dtype, name: name)
end

.assign_variable_op(resource, value, dtype: nil, name: "AssignVariableOp") ⇒ Object 



246
247
248
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 246

def self.assign_variable_op(resource, value, dtype: nil, name: "AssignVariableOp")
  self.execute("AssignVariableOp", [resource, value], dtype: dtype, name: name)
end

.atan(x, typeT: nil, name: "Atan") ⇒ Object 



250
251
252
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 250

def self.atan(x, typeT: nil, name: "Atan")
  self.execute("Atan", [x], T: typeT, name: name)
end

.atan2(y, x, typeT: nil, name: "Atan2") ⇒ Object 



254
255
256
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 254

def self.atan2(y, x, typeT: nil, name: "Atan2")
  self.execute("Atan2", [y, x], T: typeT, name: name)
end

.atanh(x, typeT: nil, name: "Atanh") ⇒ Object 



258
259
260
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 258

def self.atanh(x, typeT: nil, name: "Atanh")
  self.execute("Atanh", [x], T: typeT, name: name)
end

.audio_spectrogram(input, window_size: nil, stride: nil, magnitude_squared: false, name: "AudioSpectrogram") ⇒ Object 



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

def self.audio_spectrogram(input, window_size: nil, stride: nil, magnitude_squared: false, name: "AudioSpectrogram")
  self.execute("AudioSpectrogram", [input], window_size: window_size, stride: stride, magnitude_squared: magnitude_squared, name: name)
end

.audio_summary(tag, tensor, sample_rate: nil, max_outputs: 3, name: "AudioSummary") ⇒ Object 



266
267
268
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 266

def self.audio_summary(tag, tensor, sample_rate: nil, max_outputs: 3, name: "AudioSummary")
  self.execute("AudioSummary", [tag, tensor], sample_rate: sample_rate, max_outputs: max_outputs, name: name)
end

.audio_summary_v2(tag, tensor, sample_rate, max_outputs: 3, name: "AudioSummaryV2") ⇒ Object 



270
271
272
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 270

def self.audio_summary_v2(tag, tensor, sample_rate, max_outputs: 3, name: "AudioSummaryV2")
  self.execute("AudioSummaryV2", [tag, tensor, sample_rate], max_outputs: max_outputs, name: name)
end

.auto_shard_dataset(input_dataset, num_workers, index, auto_shard_policy: 0, output_types: nil, output_shapes: nil, name: "AutoShardDataset") ⇒ Object 



274
275
276
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 274

def self.auto_shard_dataset(input_dataset, num_workers, index, auto_shard_policy: 0, output_types: nil, output_shapes: nil, name: "AutoShardDataset")
  self.execute("AutoShardDataset", [input_dataset, num_workers, index], auto_shard_policy: auto_shard_policy, output_types: output_types, output_shapes: output_shapes, name: name)
end

.avg_pool(value, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: nil, name: "AvgPool") ⇒ Object 



278
279
280
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 278

def self.avg_pool(value, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: nil, name: "AvgPool")
  self.execute("AvgPool", [value], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.avg_pool3_d(input, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "AvgPool3D") ⇒ Object 



282
283
284
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 282

def self.avg_pool3_d(input, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "AvgPool3D")
  self.execute("AvgPool3D", [input], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.avg_pool3_d_grad(orig_input_shape, grad, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "AvgPool3DGrad") ⇒ Object 



286
287
288
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 286

def self.avg_pool3_d_grad(orig_input_shape, grad, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "AvgPool3DGrad")
  self.execute("AvgPool3DGrad", [orig_input_shape, grad], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.avg_pool_grad(orig_input_shape, grad, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: nil, name: "AvgPoolGrad") ⇒ Object 



290
291
292
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 290

def self.avg_pool_grad(orig_input_shape, grad, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: nil, name: "AvgPoolGrad")
  self.execute("AvgPoolGrad", [orig_input_shape, grad], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.barrier(component_types: nil, shapes: [], capacity: -1,, container: "", shared_name: "", name: "Barrier") ⇒ Object 



294
295
296
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 294

def self.barrier(component_types: nil, shapes: [], capacity: -1, container: "", shared_name: "", name: "Barrier")
  self.execute("Barrier", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.barrier_close(handle, cancel_pending_enqueues: false, name: "BarrierClose") ⇒ Object 



298
299
300
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 298

def self.barrier_close(handle, cancel_pending_enqueues: false, name: "BarrierClose")
  self.execute("BarrierClose", [handle], cancel_pending_enqueues: cancel_pending_enqueues, name: name)
end

.barrier_incomplete_size(handle, name: "BarrierIncompleteSize") ⇒ Object 



302
303
304
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 302

def self.barrier_incomplete_size(handle, name: "BarrierIncompleteSize")
  self.execute("BarrierIncompleteSize", [handle], name: name)
end

.barrier_insert_many(handle, keys, values, typeT: nil, component_index: nil, name: "BarrierInsertMany") ⇒ Object 



306
307
308
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 306

def self.barrier_insert_many(handle, keys, values, typeT: nil, component_index: nil, name: "BarrierInsertMany")
  self.execute("BarrierInsertMany", [handle, keys, values], T: typeT, component_index: component_index, name: name)
end

.barrier_ready_size(handle, name: "BarrierReadySize") ⇒ Object 



310
311
312
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 310

def self.barrier_ready_size(handle, name: "BarrierReadySize")
  self.execute("BarrierReadySize", [handle], name: name)
end

.barrier_take_many(handle, num_elements, component_types: nil, allow_small_batch: false, wait_for_incomplete: false, timeout_ms: -1,, name: "BarrierTakeMany") ⇒ Object 



314
315
316
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 314

def self.barrier_take_many(handle, num_elements, component_types: nil, allow_small_batch: false, wait_for_incomplete: false, timeout_ms: -1, name: "BarrierTakeMany")
  self.execute("BarrierTakeMany", [handle, num_elements], component_types: component_types, allow_small_batch: allow_small_batch, wait_for_incomplete: wait_for_incomplete, timeout_ms: timeout_ms, name: name)
end

.batch(in_tensors, num_batch_threads: nil, max_batch_size: nil, max_enqueued_batches: 10, batch_timeout_micros: nil, allowed_batch_sizes: [], grad_timeout_micros: nil, container: "", shared_name: "", batching_queue: "", typeT: nil, name: "Batch") ⇒ Object 



318
319
320
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 318

def self.batch(in_tensors, num_batch_threads: nil, max_batch_size: nil, max_enqueued_batches: 10, batch_timeout_micros: nil, allowed_batch_sizes: [], grad_timeout_micros: nil, container: "", shared_name: "", batching_queue: "", typeT: nil, name: "Batch")
  self.execute("Batch", [in_tensors], num_batch_threads: num_batch_threads, max_batch_size: max_batch_size, max_enqueued_batches: max_enqueued_batches, batch_timeout_micros: batch_timeout_micros, allowed_batch_sizes: allowed_batch_sizes, grad_timeout_micros: grad_timeout_micros, container: container, shared_name: shared_name, batching_queue: batching_queue, T: typeT, name: name)
end

.batch_cholesky(input, typeT: nil, name: "BatchCholesky") ⇒ Object 



322
323
324
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 322

def self.batch_cholesky(input, typeT: nil, name: "BatchCholesky")
  self.execute("BatchCholesky", [input], T: typeT, name: name)
end

.batch_cholesky_grad(l, grad, typeT: nil, name: "BatchCholeskyGrad") ⇒ Object 



326
327
328
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 326

def self.batch_cholesky_grad(l, grad, typeT: nil, name: "BatchCholeskyGrad")
  self.execute("BatchCholeskyGrad", [l, grad], T: typeT, name: name)
end

.batch_dataset(input_dataset, batch_size, output_types: nil, output_shapes: nil, name: "BatchDataset") ⇒ Object 



330
331
332
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 330

def self.batch_dataset(input_dataset, batch_size, output_types: nil, output_shapes: nil, name: "BatchDataset")
  self.execute("BatchDataset", [input_dataset, batch_size], output_types: output_types, output_shapes: output_shapes, name: name)
end

.batch_dataset_v2(input_dataset, batch_size, drop_remainder, parallel_copy: false, output_types: nil, output_shapes: nil, name: "BatchDatasetV2") ⇒ Object 



334
335
336
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 334

def self.batch_dataset_v2(input_dataset, batch_size, drop_remainder, parallel_copy: false, output_types: nil, output_shapes: nil, name: "BatchDatasetV2")
  self.execute("BatchDatasetV2", [input_dataset, batch_size, drop_remainder], parallel_copy: parallel_copy, output_types: output_types, output_shapes: output_shapes, name: name)
end

.batch_fft(input, name: "BatchFFT") ⇒ Object 



338
339
340
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 338

def self.batch_fft(input, name: "BatchFFT")
  self.execute("BatchFFT", [input], name: name)
end

.batch_fft2_d(input, name: "BatchFFT2D") ⇒ Object 



342
343
344
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 342

def self.batch_fft2_d(input, name: "BatchFFT2D")
  self.execute("BatchFFT2D", [input], name: name)
end

.batch_fft3_d(input, name: "BatchFFT3D") ⇒ Object 



346
347
348
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 346

def self.batch_fft3_d(input, name: "BatchFFT3D")
  self.execute("BatchFFT3D", [input], name: name)
end

.batch_function(in_tensors, captured_tensors, f: nil, num_batch_threads: nil, max_batch_size: nil, batch_timeout_micros: nil, max_enqueued_batches: 10, allowed_batch_sizes: [], container: "", shared_name: "", batching_queue: "", tin: nil, tcaptured: nil, tout: nil, name: "BatchFunction") ⇒ Object 



350
351
352
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 350

def self.batch_function(in_tensors, captured_tensors, f: nil, num_batch_threads: nil, max_batch_size: nil, batch_timeout_micros: nil, max_enqueued_batches: 10, allowed_batch_sizes: [], container: "", shared_name: "", batching_queue: "", tin: nil, tcaptured: nil, tout: nil, name: "BatchFunction")
  self.execute("BatchFunction", [in_tensors, captured_tensors], f: f, num_batch_threads: num_batch_threads, max_batch_size: max_batch_size, batch_timeout_micros: batch_timeout_micros, max_enqueued_batches: max_enqueued_batches, allowed_batch_sizes: allowed_batch_sizes, container: container, shared_name: shared_name, batching_queue: batching_queue, Tin: tin, Tcaptured: tcaptured, Tout: tout, name: name)
end

.batch_ifft(input, name: "BatchIFFT") ⇒ Object 



354
355
356
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 354

def self.batch_ifft(input, name: "BatchIFFT")
  self.execute("BatchIFFT", [input], name: name)
end

.batch_ifft2_d(input, name: "BatchIFFT2D") ⇒ Object 



358
359
360
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 358

def self.batch_ifft2_d(input, name: "BatchIFFT2D")
  self.execute("BatchIFFT2D", [input], name: name)
end

.batch_ifft3_d(input, name: "BatchIFFT3D") ⇒ Object 



362
363
364
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 362

def self.batch_ifft3_d(input, name: "BatchIFFT3D")
  self.execute("BatchIFFT3D", [input], name: name)
end

.batch_mat_mul(x, y, typeT: nil, adj_x: false, adj_y: false, name: "BatchMatMul") ⇒ Object 



366
367
368
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 366

def self.batch_mat_mul(x, y, typeT: nil, adj_x: false, adj_y: false, name: "BatchMatMul")
  self.execute("BatchMatMul", [x, y], T: typeT, adj_x: adj_x, adj_y: adj_y, name: name)
end

.batch_mat_mul_v2(x, y, typeT: nil, adj_x: false, adj_y: false, name: "BatchMatMulV2") ⇒ Object 



370
371
372
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 370

def self.batch_mat_mul_v2(x, y, typeT: nil, adj_x: false, adj_y: false, name: "BatchMatMulV2")
  self.execute("BatchMatMulV2", [x, y], T: typeT, adj_x: adj_x, adj_y: adj_y, name: name)
end

.batch_matrix_band_part(input, num_lower, num_upper, typeT: nil, name: "BatchMatrixBandPart") ⇒ Object 



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

def self.batch_matrix_band_part(input, num_lower, num_upper, typeT: nil, name: "BatchMatrixBandPart")
  self.execute("BatchMatrixBandPart", [input, num_lower, num_upper], T: typeT, name: name)
end

.batch_matrix_determinant(input, typeT: nil, name: "BatchMatrixDeterminant") ⇒ Object 



378
379
380
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 378

def self.batch_matrix_determinant(input, typeT: nil, name: "BatchMatrixDeterminant")
  self.execute("BatchMatrixDeterminant", [input], T: typeT, name: name)
end

.batch_matrix_diag(diagonal, typeT: nil, name: "BatchMatrixDiag") ⇒ Object 



382
383
384
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 382

def self.batch_matrix_diag(diagonal, typeT: nil, name: "BatchMatrixDiag")
  self.execute("BatchMatrixDiag", [diagonal], T: typeT, name: name)
end

.batch_matrix_diag_part(input, typeT: nil, name: "BatchMatrixDiagPart") ⇒ Object 



386
387
388
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 386

def self.batch_matrix_diag_part(input, typeT: nil, name: "BatchMatrixDiagPart")
  self.execute("BatchMatrixDiagPart", [input], T: typeT, name: name)
end

.batch_matrix_inverse(input, adjoint: false, typeT: nil, name: "BatchMatrixInverse") ⇒ Object 



390
391
392
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 390

def self.batch_matrix_inverse(input, adjoint: false, typeT: nil, name: "BatchMatrixInverse")
  self.execute("BatchMatrixInverse", [input], adjoint: adjoint, T: typeT, name: name)
end

.batch_matrix_set_diag(input, diagonal, typeT: nil, name: "BatchMatrixSetDiag") ⇒ Object 



394
395
396
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 394

def self.batch_matrix_set_diag(input, diagonal, typeT: nil, name: "BatchMatrixSetDiag")
  self.execute("BatchMatrixSetDiag", [input, diagonal], T: typeT, name: name)
end

.batch_matrix_solve(matrix, rhs, adjoint: false, typeT: nil, name: "BatchMatrixSolve") ⇒ Object 



398
399
400
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 398

def self.batch_matrix_solve(matrix, rhs, adjoint: false, typeT: nil, name: "BatchMatrixSolve")
  self.execute("BatchMatrixSolve", [matrix, rhs], adjoint: adjoint, T: typeT, name: name)
end

.batch_matrix_solve_ls(matrix, rhs, l2_regularizer, typeT: nil, fast: true, name: "BatchMatrixSolveLs") ⇒ Object 



402
403
404
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 402

def self.batch_matrix_solve_ls(matrix, rhs, l2_regularizer, typeT: nil, fast: true, name: "BatchMatrixSolveLs")
  self.execute("BatchMatrixSolveLs", [matrix, rhs, l2_regularizer], T: typeT, fast: fast, name: name)
end

.batch_matrix_triangular_solve(matrix, rhs, lower: true, adjoint: false, typeT: nil, name: "BatchMatrixTriangularSolve") ⇒ Object 



406
407
408
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 406

def self.batch_matrix_triangular_solve(matrix, rhs, lower: true, adjoint: false, typeT: nil, name: "BatchMatrixTriangularSolve")
  self.execute("BatchMatrixTriangularSolve", [matrix, rhs], lower: lower, adjoint: adjoint, T: typeT, name: name)
end

.batch_norm_with_global_normalization(t, m, v, beta, gamma, typeT: nil, variance_epsilon: nil, scale_after_normalization: nil, name: "BatchNormWithGlobalNormalization") ⇒ Object 



410
411
412
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 410

def self.batch_norm_with_global_normalization(t, m, v, beta, gamma, typeT: nil, variance_epsilon: nil, scale_after_normalization: nil, name: "BatchNormWithGlobalNormalization")
  self.execute("BatchNormWithGlobalNormalization", [t, m, v, beta, gamma], T: typeT, variance_epsilon: variance_epsilon, scale_after_normalization: scale_after_normalization, name: name)
end

.batch_norm_with_global_normalization_grad(t, m, v, gamma, backprop, typeT: nil, variance_epsilon: nil, scale_after_normalization: nil, name: "BatchNormWithGlobalNormalizationGrad") ⇒ Object 



414
415
416
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 414

def self.batch_norm_with_global_normalization_grad(t, m, v, gamma, backprop, typeT: nil, variance_epsilon: nil, scale_after_normalization: nil, name: "BatchNormWithGlobalNormalizationGrad")
  self.execute("BatchNormWithGlobalNormalizationGrad", [t, m, v, gamma, backprop], T: typeT, variance_epsilon: variance_epsilon, scale_after_normalization: scale_after_normalization, name: name)
end

.batch_self_adjoint_eig(input, typeT: nil, name: "BatchSelfAdjointEig") ⇒ Object 



418
419
420
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 418

def self.batch_self_adjoint_eig(input, typeT: nil, name: "BatchSelfAdjointEig")
  self.execute("BatchSelfAdjointEig", [input], T: typeT, name: name)
end

.batch_self_adjoint_eig_v2(input, compute_v: true, typeT: nil, name: "BatchSelfAdjointEigV2") ⇒ Object 



422
423
424
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 422

def self.batch_self_adjoint_eig_v2(input, compute_v: true, typeT: nil, name: "BatchSelfAdjointEigV2")
  self.execute("BatchSelfAdjointEigV2", [input], compute_v: compute_v, T: typeT, name: name)
end

.batch_svd(input, compute_uv: true, full_matrices: false, typeT: nil, name: "BatchSvd") ⇒ Object 



426
427
428
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 426

def self.batch_svd(input, compute_uv: true, full_matrices: false, typeT: nil, name: "BatchSvd")
  self.execute("BatchSvd", [input], compute_uv: compute_uv, full_matrices: full_matrices, T: typeT, name: name)
end

.batch_to_space(input, crops, typeT: nil, block_size: nil, tidx: :int32, name: "BatchToSpace") ⇒ Object 



430
431
432
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 430

def self.batch_to_space(input, crops, typeT: nil, block_size: nil, tidx: :int32, name: "BatchToSpace")
  self.execute("BatchToSpace", [input, crops], T: typeT, block_size: block_size, Tidx: tidx, name: name)
end

.batch_to_space_nd(input, block_shape, crops, typeT: nil, tblock_shape: :int32, tcrops: :int32, name: "BatchToSpaceND") ⇒ Object 



434
435
436
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 434

def self.batch_to_space_nd(input, block_shape, crops, typeT: nil, tblock_shape: :int32, tcrops: :int32, name: "BatchToSpaceND")
  self.execute("BatchToSpaceND", [input, block_shape, crops], T: typeT, Tblock_shape: tblock_shape, Tcrops: tcrops, name: name)
end

.bessel_i0e(x, typeT: nil, name: "BesselI0e") ⇒ Object 



438
439
440
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 438

def self.bessel_i0e(x, typeT: nil, name: "BesselI0e")
  self.execute("BesselI0e", [x], T: typeT, name: name)
end

.bessel_i1e(x, typeT: nil, name: "BesselI1e") ⇒ Object 



442
443
444
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 442

def self.bessel_i1e(x, typeT: nil, name: "BesselI1e")
  self.execute("BesselI1e", [x], T: typeT, name: name)
end

.betainc(a, b, x, typeT: nil, name: "Betainc") ⇒ Object 



446
447
448
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 446

def self.betainc(a, b, x, typeT: nil, name: "Betainc")
  self.execute("Betainc", [a, b, x], T: typeT, name: name)
end

.bias_add(value, bias, typeT: nil, data_format: "NHWC", name: "BiasAdd") ⇒ Object 



450
451
452
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 450

def self.bias_add(value, bias, typeT: nil, data_format: "NHWC", name: "BiasAdd")
  self.execute("BiasAdd", [value, bias], T: typeT, data_format: data_format, name: name)
end

.bias_add_grad(out_backprop, typeT: nil, data_format: "NHWC", name: "BiasAddGrad") ⇒ Object 



454
455
456
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 454

def self.bias_add_grad(out_backprop, typeT: nil, data_format: "NHWC", name: "BiasAddGrad")
  self.execute("BiasAddGrad", [out_backprop], T: typeT, data_format: data_format, name: name)
end

.bias_add_v1(value, bias, typeT: nil, name: "BiasAddV1") ⇒ Object 



458
459
460
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 458

def self.bias_add_v1(value, bias, typeT: nil, name: "BiasAddV1")
  self.execute("BiasAddV1", [value, bias], T: typeT, name: name)
end

.bincount(arr, size, weights, typeT: nil, name: "Bincount") ⇒ Object 



462
463
464
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 462

def self.bincount(arr, size, weights, typeT: nil, name: "Bincount")
  self.execute("Bincount", [arr, size, weights], T: typeT, name: name)
end

.bitcast(input, typeT: nil, type: nil, name: "Bitcast") ⇒ Object 



466
467
468
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 466

def self.bitcast(input, typeT: nil, type: nil, name: "Bitcast")
  self.execute("Bitcast", [input], T: typeT, type: type, name: name)
end

.bitwise_and(x, y, typeT: nil, name: "BitwiseAnd") ⇒ Object 



470
471
472
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 470

def self.bitwise_and(x, y, typeT: nil, name: "BitwiseAnd")
  self.execute("BitwiseAnd", [x, y], T: typeT, name: name)
end

.bitwise_or(x, y, typeT: nil, name: "BitwiseOr") ⇒ Object 



474
475
476
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 474

def self.bitwise_or(x, y, typeT: nil, name: "BitwiseOr")
  self.execute("BitwiseOr", [x, y], T: typeT, name: name)
end

.bitwise_xor(x, y, typeT: nil, name: "BitwiseXor") ⇒ Object 



478
479
480
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 478

def self.bitwise_xor(x, y, typeT: nil, name: "BitwiseXor")
  self.execute("BitwiseXor", [x, y], T: typeT, name: name)
end

.block_lstm(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias: 1.0, cell_clip: 3.0, use_peephole: false, typeT: nil, name: "BlockLSTM") ⇒ Object 



482
483
484
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 482

def self.block_lstm(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias: 1.0, cell_clip: 3.0, use_peephole: false, typeT: nil, name: "BlockLSTM")
  self.execute("BlockLSTM", [seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b], forget_bias: forget_bias, cell_clip: cell_clip, use_peephole: use_peephole, T: typeT, name: name)
end

.block_lstm_grad(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad, use_peephole: nil, typeT: nil, name: "BlockLSTMGrad") ⇒ Object 



486
487
488
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 486

def self.block_lstm_grad(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad, use_peephole: nil, typeT: nil, name: "BlockLSTMGrad")
  self.execute("BlockLSTMGrad", [seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad], use_peephole: use_peephole, T: typeT, name: name)
end

.block_lstm_grad_v2(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad, use_peephole: nil, typeT: nil, name: "BlockLSTMGradV2") ⇒ Object 



490
491
492
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 490

def self.block_lstm_grad_v2(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad, use_peephole: nil, typeT: nil, name: "BlockLSTMGradV2")
  self.execute("BlockLSTMGradV2", [seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad], use_peephole: use_peephole, T: typeT, name: name)
end

.block_lstmv2(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, cell_clip: 0.0, use_peephole: false, typeT: nil, name: "BlockLSTMV2") ⇒ Object 



494
495
496
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 494

def self.block_lstmv2(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, cell_clip: 0.0, use_peephole: false, typeT: nil, name: "BlockLSTMV2")
  self.execute("BlockLSTMV2", [seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b], cell_clip: cell_clip, use_peephole: use_peephole, T: typeT, name: name)
end

.boosted_trees_aggregate_stats(node_ids, gradients, hessians, feature, max_splits: nil, num_buckets: nil, name: "BoostedTreesAggregateStats") ⇒ Object 



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

def self.boosted_trees_aggregate_stats(node_ids, gradients, hessians, feature, max_splits: nil, num_buckets: nil, name: "BoostedTreesAggregateStats")
  self.execute("BoostedTreesAggregateStats", [node_ids, gradients, hessians, feature], max_splits: max_splits, num_buckets: num_buckets, name: name)
end

.boosted_trees_bucketize(float_values, bucket_boundaries, num_features: nil, name: "BoostedTreesBucketize") ⇒ Object 



502
503
504
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 502

def self.boosted_trees_bucketize(float_values, bucket_boundaries, num_features: nil, name: "BoostedTreesBucketize")
  self.execute("BoostedTreesBucketize", [float_values, bucket_boundaries], num_features: num_features, name: name)
end

.boosted_trees_calculate_best_feature_split(node_id_range, stats_summary, l1, l2, tree_complexity, min_node_weight, logits_dimension: nil, split_type: "inequality", name: "BoostedTreesCalculateBestFeatureSplit") ⇒ Object 



506
507
508
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 506

def self.boosted_trees_calculate_best_feature_split(node_id_range, stats_summary, l1, l2, tree_complexity, min_node_weight, logits_dimension: nil, split_type: "inequality", name: "BoostedTreesCalculateBestFeatureSplit")
  self.execute("BoostedTreesCalculateBestFeatureSplit", [node_id_range, stats_summary, l1, l2, tree_complexity, min_node_weight], logits_dimension: logits_dimension, split_type: split_type, name: name)
end

.boosted_trees_calculate_best_gains_per_feature(node_id_range, stats_summary_list, l1, l2, tree_complexity, min_node_weight, max_splits: nil, num_features: nil, name: "BoostedTreesCalculateBestGainsPerFeature") ⇒ Object 



510
511
512
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 510

def self.boosted_trees_calculate_best_gains_per_feature(node_id_range, stats_summary_list, l1, l2, tree_complexity, min_node_weight, max_splits: nil, num_features: nil, name: "BoostedTreesCalculateBestGainsPerFeature")
  self.execute("BoostedTreesCalculateBestGainsPerFeature", [node_id_range, stats_summary_list, l1, l2, tree_complexity, min_node_weight], max_splits: max_splits, num_features: num_features, name: name)
end

.boosted_trees_center_bias(tree_ensemble_handle, mean_gradients, mean_hessians, l1, l2, name: "BoostedTreesCenterBias") ⇒ Object 



514
515
516
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 514

def self.boosted_trees_center_bias(tree_ensemble_handle, mean_gradients, mean_hessians, l1, l2, name: "BoostedTreesCenterBias")
  self.execute("BoostedTreesCenterBias", [tree_ensemble_handle, mean_gradients, mean_hessians, l1, l2], name: name)
end

.boosted_trees_create_ensemble(tree_ensemble_handle, stamp_token, tree_ensemble_serialized, name: "BoostedTreesCreateEnsemble") ⇒ Object 



518
519
520
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 518

def self.boosted_trees_create_ensemble(tree_ensemble_handle, stamp_token, tree_ensemble_serialized, name: "BoostedTreesCreateEnsemble")
  self.execute("BoostedTreesCreateEnsemble", [tree_ensemble_handle, stamp_token, tree_ensemble_serialized], name: name)
end

.boosted_trees_create_quantile_stream_resource(quantile_stream_resource_handle, epsilon, num_streams, max_elements: 1099511627776, name: "BoostedTreesCreateQuantileStreamResource") ⇒ Object 



522
523
524
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 522

def self.boosted_trees_create_quantile_stream_resource(quantile_stream_resource_handle, epsilon, num_streams, max_elements: 1099511627776, name: "BoostedTreesCreateQuantileStreamResource")
  self.execute("BoostedTreesCreateQuantileStreamResource", [quantile_stream_resource_handle, epsilon, num_streams], max_elements: max_elements, name: name)
end

.boosted_trees_deserialize_ensemble(tree_ensemble_handle, stamp_token, tree_ensemble_serialized, name: "BoostedTreesDeserializeEnsemble") ⇒ Object 



526
527
528
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 526

def self.boosted_trees_deserialize_ensemble(tree_ensemble_handle, stamp_token, tree_ensemble_serialized, name: "BoostedTreesDeserializeEnsemble")
  self.execute("BoostedTreesDeserializeEnsemble", [tree_ensemble_handle, stamp_token, tree_ensemble_serialized], name: name)
end

.boosted_trees_ensemble_resource_handle_op(container: "", shared_name: "", name: "BoostedTreesEnsembleResourceHandleOp") ⇒ Object 



530
531
532
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 530

def self.boosted_trees_ensemble_resource_handle_op(container: "", shared_name: "", name: "BoostedTreesEnsembleResourceHandleOp")
  self.execute("BoostedTreesEnsembleResourceHandleOp", [], container: container, shared_name: shared_name, name: name)
end

.boosted_trees_example_debug_outputs(tree_ensemble_handle, bucketized_features, num_bucketized_features: nil, logits_dimension: nil, name: "BoostedTreesExampleDebugOutputs") ⇒ Object 



534
535
536
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 534

def self.boosted_trees_example_debug_outputs(tree_ensemble_handle, bucketized_features, num_bucketized_features: nil, logits_dimension: nil, name: "BoostedTreesExampleDebugOutputs")
  self.execute("BoostedTreesExampleDebugOutputs", [tree_ensemble_handle, bucketized_features], num_bucketized_features: num_bucketized_features, logits_dimension: logits_dimension, name: name)
end

.boosted_trees_flush_quantile_summaries(quantile_stream_resource_handle, num_features: nil, name: "BoostedTreesFlushQuantileSummaries") ⇒ Object 



538
539
540
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 538

def self.boosted_trees_flush_quantile_summaries(quantile_stream_resource_handle, num_features: nil, name: "BoostedTreesFlushQuantileSummaries")
  self.execute("BoostedTreesFlushQuantileSummaries", [quantile_stream_resource_handle], num_features: num_features, name: name)
end

.boosted_trees_get_ensemble_states(tree_ensemble_handle, name: "BoostedTreesGetEnsembleStates") ⇒ Object 



542
543
544
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 542

def self.boosted_trees_get_ensemble_states(tree_ensemble_handle, name: "BoostedTreesGetEnsembleStates")
  self.execute("BoostedTreesGetEnsembleStates", [tree_ensemble_handle], name: name)
end

.boosted_trees_make_quantile_summaries(float_values, example_weights, epsilon, num_features: nil, name: "BoostedTreesMakeQuantileSummaries") ⇒ Object 



546
547
548
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 546

def self.boosted_trees_make_quantile_summaries(float_values, example_weights, epsilon, num_features: nil, name: "BoostedTreesMakeQuantileSummaries")
  self.execute("BoostedTreesMakeQuantileSummaries", [float_values, example_weights, epsilon], num_features: num_features, name: name)
end

.boosted_trees_make_stats_summary(node_ids, gradients, hessians, bucketized_features_list, max_splits: nil, num_buckets: nil, num_features: nil, name: "BoostedTreesMakeStatsSummary") ⇒ Object 



550
551
552
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 550

def self.boosted_trees_make_stats_summary(node_ids, gradients, hessians, bucketized_features_list, max_splits: nil, num_buckets: nil, num_features: nil, name: "BoostedTreesMakeStatsSummary")
  self.execute("BoostedTreesMakeStatsSummary", [node_ids, gradients, hessians, bucketized_features_list], max_splits: max_splits, num_buckets: num_buckets, num_features: num_features, name: name)
end

.boosted_trees_predict(tree_ensemble_handle, bucketized_features, num_bucketized_features: nil, logits_dimension: nil, name: "BoostedTreesPredict") ⇒ Object 



554
555
556
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 554

def self.boosted_trees_predict(tree_ensemble_handle, bucketized_features, num_bucketized_features: nil, logits_dimension: nil, name: "BoostedTreesPredict")
  self.execute("BoostedTreesPredict", [tree_ensemble_handle, bucketized_features], num_bucketized_features: num_bucketized_features, logits_dimension: logits_dimension, name: name)
end

.boosted_trees_quantile_stream_resource_add_summaries(quantile_stream_resource_handle, summaries, num_features: nil, name: "BoostedTreesQuantileStreamResourceAddSummaries") ⇒ Object 



558
559
560
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 558

def self.boosted_trees_quantile_stream_resource_add_summaries(quantile_stream_resource_handle, summaries, num_features: nil, name: "BoostedTreesQuantileStreamResourceAddSummaries")
  self.execute("BoostedTreesQuantileStreamResourceAddSummaries", [quantile_stream_resource_handle, summaries], num_features: num_features, name: name)
end

.boosted_trees_quantile_stream_resource_deserialize(quantile_stream_resource_handle, bucket_boundaries, num_streams: nil, name: "BoostedTreesQuantileStreamResourceDeserialize") ⇒ Object 



562
563
564
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 562

def self.boosted_trees_quantile_stream_resource_deserialize(quantile_stream_resource_handle, bucket_boundaries, num_streams: nil, name: "BoostedTreesQuantileStreamResourceDeserialize")
  self.execute("BoostedTreesQuantileStreamResourceDeserialize", [quantile_stream_resource_handle, bucket_boundaries], num_streams: num_streams, name: name)
end

.boosted_trees_quantile_stream_resource_flush(quantile_stream_resource_handle, num_buckets, generate_quantiles: false, name: "BoostedTreesQuantileStreamResourceFlush") ⇒ Object 



566
567
568
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 566

def self.boosted_trees_quantile_stream_resource_flush(quantile_stream_resource_handle, num_buckets, generate_quantiles: false, name: "BoostedTreesQuantileStreamResourceFlush")
  self.execute("BoostedTreesQuantileStreamResourceFlush", [quantile_stream_resource_handle, num_buckets], generate_quantiles: generate_quantiles, name: name)
end

.boosted_trees_quantile_stream_resource_get_bucket_boundaries(quantile_stream_resource_handle, num_features: nil, name: "BoostedTreesQuantileStreamResourceGetBucketBoundaries") ⇒ Object 



570
571
572
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 570

def self.boosted_trees_quantile_stream_resource_get_bucket_boundaries(quantile_stream_resource_handle, num_features: nil, name: "BoostedTreesQuantileStreamResourceGetBucketBoundaries")
  self.execute("BoostedTreesQuantileStreamResourceGetBucketBoundaries", [quantile_stream_resource_handle], num_features: num_features, name: name)
end

.boosted_trees_quantile_stream_resource_handle_op(container: "", shared_name: "", name: "BoostedTreesQuantileStreamResourceHandleOp") ⇒ Object 



574
575
576
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 574

def self.boosted_trees_quantile_stream_resource_handle_op(container: "", shared_name: "", name: "BoostedTreesQuantileStreamResourceHandleOp")
  self.execute("BoostedTreesQuantileStreamResourceHandleOp", [], container: container, shared_name: shared_name, name: name)
end

.boosted_trees_serialize_ensemble(tree_ensemble_handle, name: "BoostedTreesSerializeEnsemble") ⇒ Object 



578
579
580
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 578

def self.boosted_trees_serialize_ensemble(tree_ensemble_handle, name: "BoostedTreesSerializeEnsemble")
  self.execute("BoostedTreesSerializeEnsemble", [tree_ensemble_handle], name: name)
end

.boosted_trees_sparse_aggregate_stats(node_ids, gradients, hessians, feature_indices, feature_values, feature_shape, max_splits: nil, num_buckets: nil, name: "BoostedTreesSparseAggregateStats") ⇒ Object 



582
583
584
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 582

def self.boosted_trees_sparse_aggregate_stats(node_ids, gradients, hessians, feature_indices, feature_values, feature_shape, max_splits: nil, num_buckets: nil, name: "BoostedTreesSparseAggregateStats")
  self.execute("BoostedTreesSparseAggregateStats", [node_ids, gradients, hessians, feature_indices, feature_values, feature_shape], max_splits: max_splits, num_buckets: num_buckets, name: name)
end

.boosted_trees_sparse_calculate_best_feature_split(node_id_range, stats_summary_indices, stats_summary_values, stats_summary_shape, l1, l2, tree_complexity, min_node_weight, logits_dimension: nil, split_type: "inequality", name: "BoostedTreesSparseCalculateBestFeatureSplit") ⇒ Object 



586
587
588
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 586

def self.boosted_trees_sparse_calculate_best_feature_split(node_id_range, stats_summary_indices, stats_summary_values, stats_summary_shape, l1, l2, tree_complexity, min_node_weight, logits_dimension: nil, split_type: "inequality", name: "BoostedTreesSparseCalculateBestFeatureSplit")
  self.execute("BoostedTreesSparseCalculateBestFeatureSplit", [node_id_range, stats_summary_indices, stats_summary_values, stats_summary_shape, l1, l2, tree_complexity, min_node_weight], logits_dimension: logits_dimension, split_type: split_type, name: name)
end

.boosted_trees_training_predict(tree_ensemble_handle, cached_tree_ids, cached_node_ids, bucketized_features, num_bucketized_features: nil, logits_dimension: nil, name: "BoostedTreesTrainingPredict") ⇒ Object 



590
591
592
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 590

def self.boosted_trees_training_predict(tree_ensemble_handle, cached_tree_ids, cached_node_ids, bucketized_features, num_bucketized_features: nil, logits_dimension: nil, name: "BoostedTreesTrainingPredict")
  self.execute("BoostedTreesTrainingPredict", [tree_ensemble_handle, cached_tree_ids, cached_node_ids, bucketized_features], num_bucketized_features: num_bucketized_features, logits_dimension: logits_dimension, name: name)
end

.boosted_trees_update_ensemble(tree_ensemble_handle, feature_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, max_depth, learning_rate, pruning_mode: nil, num_features: nil, name: "BoostedTreesUpdateEnsemble") ⇒ Object 



594
595
596
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 594

def self.boosted_trees_update_ensemble(tree_ensemble_handle, feature_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, max_depth, learning_rate, pruning_mode: nil, num_features: nil, name: "BoostedTreesUpdateEnsemble")
  self.execute("BoostedTreesUpdateEnsemble", [tree_ensemble_handle, feature_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, max_depth, learning_rate], pruning_mode: pruning_mode, num_features: num_features, name: name)
end

.boosted_trees_update_ensemble_v2(tree_ensemble_handle, feature_ids, dimension_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, split_types, max_depth, learning_rate, pruning_mode, num_features: nil, logits_dimension: 1, name: "BoostedTreesUpdateEnsembleV2") ⇒ Object 



598
599
600
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 598

def self.boosted_trees_update_ensemble_v2(tree_ensemble_handle, feature_ids, dimension_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, split_types, max_depth, learning_rate, pruning_mode, num_features: nil, logits_dimension: 1, name: "BoostedTreesUpdateEnsembleV2")
  self.execute("BoostedTreesUpdateEnsembleV2", [tree_ensemble_handle, feature_ids, dimension_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, split_types, max_depth, learning_rate, pruning_mode], num_features: num_features, logits_dimension: logits_dimension, name: name)
end

.broadcast_args(s0, s1, typeT: :int32, name: "BroadcastArgs") ⇒ Object 



602
603
604
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 602

def self.broadcast_args(s0, s1, typeT: :int32, name: "BroadcastArgs")
  self.execute("BroadcastArgs", [s0, s1], T: typeT, name: name)
end

.broadcast_gradient_args(s0, s1, typeT: :int32, name: "BroadcastGradientArgs") ⇒ Object 



606
607
608
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 606

def self.broadcast_gradient_args(s0, s1, typeT: :int32, name: "BroadcastGradientArgs")
  self.execute("BroadcastGradientArgs", [s0, s1], T: typeT, name: name)
end

.broadcast_to(input, shape, typeT: nil, tidx: :int32, name: "BroadcastTo") ⇒ Object 



610
611
612
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 610

def self.broadcast_to(input, shape, typeT: nil, tidx: :int32, name: "BroadcastTo")
  self.execute("BroadcastTo", [input, shape], T: typeT, Tidx: tidx, name: name)
end

.bucketize(input, typeT: nil, boundaries: nil, name: "Bucketize") ⇒ Object 



614
615
616
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 614

def self.bucketize(input, typeT: nil, boundaries: nil, name: "Bucketize")
  self.execute("Bucketize", [input], T: typeT, boundaries: boundaries, name: name)
end

.bytes_produced_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "BytesProducedStatsDataset") ⇒ Object 



618
619
620
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 618

def self.bytes_produced_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "BytesProducedStatsDataset")
  self.execute("BytesProducedStatsDataset", [input_dataset, tag], output_types: output_types, output_shapes: output_shapes, name: name)
end

.cache_dataset(input_dataset, filename, output_types: nil, output_shapes: nil, name: "CacheDataset") ⇒ Object 



650
651
652
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 650

def self.cache_dataset(input_dataset, filename, output_types: nil, output_shapes: nil, name: "CacheDataset")
  self.execute("CacheDataset", [input_dataset, filename], output_types: output_types, output_shapes: output_shapes, name: name)
end

.cache_dataset_v2(input_dataset, filename, cache, output_types: nil, output_shapes: nil, name: "CacheDatasetV2") ⇒ Object 



654
655
656
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 654

def self.cache_dataset_v2(input_dataset, filename, cache, output_types: nil, output_shapes: nil, name: "CacheDatasetV2")
  self.execute("CacheDatasetV2", [input_dataset, filename, cache], output_types: output_types, output_shapes: output_shapes, name: name)
end

.case(branch_index, input, tin: nil, tout: nil, branches: nil, output_shapes: [], name: "Case") ⇒ Object 



658
659
660
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 658

def self.case(branch_index, input, tin: nil, tout: nil, branches: nil, output_shapes: [], name: "Case")
  self.execute("Case", [branch_index, input], Tin: tin, Tout: tout, branches: branches, output_shapes: output_shapes, name: name)
end

.cast(x, srct: nil, dstt: nil, truncate: false, name: "Cast") ⇒ Object 



662
663
664
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 662

def self.cast(x, srct: nil, dstt: nil, truncate: false, name: "Cast")
  self.execute("Cast", [x], SrcT: srct, DstT: dstt, Truncate: truncate, name: name)
end

.ceil(x, typeT: nil, name: "Ceil") ⇒ Object 



666
667
668
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 666

def self.ceil(x, typeT: nil, name: "Ceil")
  self.execute("Ceil", [x], T: typeT, name: name)
end

.check_numerics(tensor, typeT: nil, message: "", name: "CheckNumerics") ⇒ Object 



670
671
672
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 670

def self.check_numerics(tensor, typeT: nil, message: "", name: "CheckNumerics")
  self.execute("CheckNumerics", [tensor], T: typeT, message: message, name: name)
end

.cholesky(input, typeT: nil, name: "Cholesky") ⇒ Object 



674
675
676
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 674

def self.cholesky(input, typeT: nil, name: "Cholesky")
  self.execute("Cholesky", [input], T: typeT, name: name)
end

.cholesky_grad(l, grad, typeT: nil, name: "CholeskyGrad") ⇒ Object 



678
679
680
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 678

def self.cholesky_grad(l, grad, typeT: nil, name: "CholeskyGrad")
  self.execute("CholeskyGrad", [l, grad], T: typeT, name: name)
end

.choose_fastest_branch_dataset(input_dataset, ratio_numerator, ratio_denominator, other_arguments, targuments: nil, num_elements_per_branch: nil, branches: nil, other_arguments_lengths: nil, output_types: nil, output_shapes: nil, name: "ChooseFastestBranchDataset") ⇒ Object 



682
683
684
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 682

def self.choose_fastest_branch_dataset(input_dataset, ratio_numerator, ratio_denominator, other_arguments, targuments: nil, num_elements_per_branch: nil, branches: nil, other_arguments_lengths: nil, output_types: nil, output_shapes: nil, name: "ChooseFastestBranchDataset")
  self.execute("ChooseFastestBranchDataset", [input_dataset, ratio_numerator, ratio_denominator, other_arguments], Targuments: targuments, num_elements_per_branch: num_elements_per_branch, branches: branches, other_arguments_lengths: other_arguments_lengths, output_types: output_types, output_shapes: output_shapes, name: name)
end

.choose_fastest_dataset(input_datasets, n: nil, num_experiments: nil, output_types: nil, output_shapes: nil, name: "ChooseFastestDataset") ⇒ Object 



686
687
688
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 686

def self.choose_fastest_dataset(input_datasets, n: nil, num_experiments: nil, output_types: nil, output_shapes: nil, name: "ChooseFastestDataset")
  self.execute("ChooseFastestDataset", [input_datasets], N: n, num_experiments: num_experiments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.clip_by_value(t, clip_value_min, clip_value_max, typeT: nil, name: "ClipByValue") ⇒ Object 



690
691
692
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 690

def self.clip_by_value(t, clip_value_min, clip_value_max, typeT: nil, name: "ClipByValue")
  self.execute("ClipByValue", [t, clip_value_min, clip_value_max], T: typeT, name: name)
end

.close_summary_writer(writer, name: "CloseSummaryWriter") ⇒ Object 



694
695
696
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 694

def self.close_summary_writer(writer, name: "CloseSummaryWriter")
  self.execute("CloseSummaryWriter", [writer], name: name)
end

.collective_bcast_recv(typeT: nil, group_size: nil, group_key: nil, instance_key: nil, shape: nil, communication_hint: "auto", name: "CollectiveBcastRecv") ⇒ Object 



698
699
700
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 698

def self.collective_bcast_recv(typeT: nil, group_size: nil, group_key: nil, instance_key: nil, shape: nil, communication_hint: "auto", name: "CollectiveBcastRecv")
  self.execute("CollectiveBcastRecv", [], T: typeT, group_size: group_size, group_key: group_key, instance_key: instance_key, shape: shape, communication_hint: communication_hint, name: name)
end

.collective_bcast_send(input, typeT: nil, group_size: nil, group_key: nil, instance_key: nil, shape: nil, communication_hint: "auto", name: "CollectiveBcastSend") ⇒ Object 



702
703
704
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 702

def self.collective_bcast_send(input, typeT: nil, group_size: nil, group_key: nil, instance_key: nil, shape: nil, communication_hint: "auto", name: "CollectiveBcastSend")
  self.execute("CollectiveBcastSend", [input], T: typeT, group_size: group_size, group_key: group_key, instance_key: instance_key, shape: shape, communication_hint: communication_hint, name: name)
end

.collective_gather(input, typeT: nil, group_size: nil, group_key: nil, instance_key: nil, shape: nil, communication_hint: "auto", name: "CollectiveGather") ⇒ Object 



706
707
708
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 706

def self.collective_gather(input, typeT: nil, group_size: nil, group_key: nil, instance_key: nil, shape: nil, communication_hint: "auto", name: "CollectiveGather")
  self.execute("CollectiveGather", [input], T: typeT, group_size: group_size, group_key: group_key, instance_key: instance_key, shape: shape, communication_hint: communication_hint, name: name)
end

.collective_permute(input, source_target_pairs, typeT: nil, name: "CollectivePermute") ⇒ Object 



710
711
712
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 710

def self.collective_permute(input, source_target_pairs, typeT: nil, name: "CollectivePermute")
  self.execute("CollectivePermute", [input, source_target_pairs], T: typeT, name: name)
end

.collective_reduce(input, typeT: nil, group_size: nil, group_key: nil, instance_key: nil, merge_op: nil, final_op: nil, subdiv_offsets: nil, wait_for: [], communication_hint: "auto", name: "CollectiveReduce") ⇒ Object 



714
715
716
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 714

def self.collective_reduce(input, typeT: nil, group_size: nil, group_key: nil, instance_key: nil, merge_op: nil, final_op: nil, subdiv_offsets: nil, wait_for: [], communication_hint: "auto", name: "CollectiveReduce")
  self.execute("CollectiveReduce", [input], T: typeT, group_size: group_size, group_key: group_key, instance_key: instance_key, merge_op: merge_op, final_op: final_op, subdiv_offsets: subdiv_offsets, wait_for: wait_for, communication_hint: communication_hint, name: name)
end

.combined_non_max_suppression(boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold, pad_per_class: false, clip_boxes: true, name: "CombinedNonMaxSuppression") ⇒ Object 



718
719
720
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 718

def self.combined_non_max_suppression(boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold, pad_per_class: false, clip_boxes: true, name: "CombinedNonMaxSuppression")
  self.execute("CombinedNonMaxSuppression", [boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold], pad_per_class: pad_per_class, clip_boxes: clip_boxes, name: name)
end

.compare_and_bitpack(input, threshold, typeT: nil, name: "CompareAndBitpack") ⇒ Object 



722
723
724
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 722

def self.compare_and_bitpack(input, threshold, typeT: nil, name: "CompareAndBitpack")
  self.execute("CompareAndBitpack", [input, threshold], T: typeT, name: name)
end

.complex(real, imag, typeT: :float, tout: :complex64, name: "Complex") ⇒ Object 



726
727
728
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 726

def self.complex(real, imag, typeT: :float, tout: :complex64, name: "Complex")
  self.execute("Complex", [real, imag], T: typeT, Tout: tout, name: name)
end

.complex_abs(x, typeT: :complex64, tout: :float, name: "ComplexAbs") ⇒ Object 



730
731
732
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 730

def self.complex_abs(x, typeT: :complex64, tout: :float, name: "ComplexAbs")
  self.execute("ComplexAbs", [x], T: typeT, Tout: tout, name: name)
end

.compute_accidental_hits(true_classes, sampled_candidates, num_true: nil, seed: 0, seed2: 0, name: "ComputeAccidentalHits") ⇒ Object 



734
735
736
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 734

def self.compute_accidental_hits(true_classes, sampled_candidates, num_true: nil, seed: 0, seed2: 0, name: "ComputeAccidentalHits")
  self.execute("ComputeAccidentalHits", [true_classes, sampled_candidates], num_true: num_true, seed: seed, seed2: seed2, name: name)
end

.concat(concat_dim, values, n: nil, typeT: nil, name: "Concat") ⇒ Object 



738
739
740
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 738

def self.concat(concat_dim, values, n: nil, typeT: nil, name: "Concat")
  self.execute("Concat", [concat_dim, values], N: n, T: typeT, name: name)
end

.concat_offset(concat_dim, shape, n: nil, name: "ConcatOffset") ⇒ Object 



742
743
744
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 742

def self.concat_offset(concat_dim, shape, n: nil, name: "ConcatOffset")
  self.execute("ConcatOffset", [concat_dim, shape], N: n, name: name)
end

.concat_v2(values, axis, n: nil, typeT: nil, tidx: :int32, name: "ConcatV2") ⇒ Object 



746
747
748
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 746

def self.concat_v2(values, axis, n: nil, typeT: nil, tidx: :int32, name: "ConcatV2")
  self.execute("ConcatV2", [values, axis], N: n, T: typeT, Tidx: tidx, name: name)
end

.concatenate_dataset(input_dataset, another_dataset, output_types: nil, output_shapes: nil, name: "ConcatenateDataset") ⇒ Object 



750
751
752
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 750

def self.concatenate_dataset(input_dataset, another_dataset, output_types: nil, output_shapes: nil, name: "ConcatenateDataset")
  self.execute("ConcatenateDataset", [input_dataset, another_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.conditional_accumulator(dtype: nil, shape: nil, container: "", shared_name: "", reduction_type: "MEAN", name: "ConditionalAccumulator") ⇒ Object 



754
755
756
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 754

def self.conditional_accumulator(dtype: nil, shape: nil, container: "", shared_name: "", reduction_type: "MEAN", name: "ConditionalAccumulator")
  self.execute("ConditionalAccumulator", [], dtype: dtype, shape: shape, container: container, shared_name: shared_name, reduction_type: reduction_type, name: name)
end

.configure_distributed_tpu(embedding_config: "", tpu_embedding_config: "", is_global_init: false, enable_whole_mesh_compilations: false, name: "ConfigureDistributedTPU") ⇒ Object 



758
759
760
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 758

def self.configure_distributed_tpu(embedding_config: "", tpu_embedding_config: "", is_global_init: false, enable_whole_mesh_compilations: false, name: "ConfigureDistributedTPU")
  self.execute("ConfigureDistributedTPU", [], embedding_config: embedding_config, tpu_embedding_config: tpu_embedding_config, is_global_init: is_global_init, enable_whole_mesh_compilations: enable_whole_mesh_compilations, name: name)
end

.configure_tpu_embedding(config: "", name: "ConfigureTPUEmbedding") ⇒ Object 



762
763
764
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 762

def self.configure_tpu_embedding(config: "", name: "ConfigureTPUEmbedding")
  self.execute("ConfigureTPUEmbedding", [], config: config, name: name)
end

.conj(input, typeT: :complex64, name: "Conj") ⇒ Object 



766
767
768
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 766

def self.conj(input, typeT: :complex64, name: "Conj")
  self.execute("Conj", [input], T: typeT, name: name)
end

.conjugate_transpose(x, perm, typeT: nil, tperm: :int32, name: "ConjugateTranspose") ⇒ Object 



770
771
772
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 770

def self.conjugate_transpose(x, perm, typeT: nil, tperm: :int32, name: "ConjugateTranspose")
  self.execute("ConjugateTranspose", [x, perm], T: typeT, Tperm: tperm, name: name)
end

.const(value: nil, dtype: nil, name: "Const") ⇒ Object 



774
775
776
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 774

def self.const(value: nil, dtype: nil, name: "Const")
  self.execute("Const", [], value: value, dtype: dtype, name: name)
end

.consume_mutex_lock(mutex_lock, name: "ConsumeMutexLock") ⇒ Object 



778
779
780
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 778

def self.consume_mutex_lock(mutex_lock, name: "ConsumeMutexLock")
  self.execute("ConsumeMutexLock", [mutex_lock], name: name)
end

.control_trigger(name: "ControlTrigger") ⇒ Object 



782
783
784
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 782

def self.control_trigger(name: "ControlTrigger")
  self.execute("ControlTrigger", [], name: name)
end

.conv2_d(input, filter, typeT: nil, strides: nil, use_cudnn_on_gpu: true, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], name: "Conv2D") ⇒ Object 



786
787
788
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 786

def self.conv2_d(input, filter, typeT: nil, strides: nil, use_cudnn_on_gpu: true, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], name: "Conv2D")
  self.execute("Conv2D", [input, filter], T: typeT, strides: strides, use_cudnn_on_gpu: use_cudnn_on_gpu, padding: padding, explicit_paddings: explicit_paddings, data_format: data_format, dilations: dilations, name: name)
end

.conv2_d_backprop_filter(input, filter_sizes, out_backprop, typeT: nil, strides: nil, use_cudnn_on_gpu: true, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], name: "Conv2DBackpropFilter") ⇒ Object 



790
791
792
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 790

def self.conv2_d_backprop_filter(input, filter_sizes, out_backprop, typeT: nil, strides: nil, use_cudnn_on_gpu: true, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], name: "Conv2DBackpropFilter")
  self.execute("Conv2DBackpropFilter", [input, filter_sizes, out_backprop], T: typeT, strides: strides, use_cudnn_on_gpu: use_cudnn_on_gpu, padding: padding, explicit_paddings: explicit_paddings, data_format: data_format, dilations: dilations, name: name)
end

.conv2_d_backprop_input(input_sizes, filter, out_backprop, typeT: nil, strides: nil, use_cudnn_on_gpu: true, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], name: "Conv2DBackpropInput") ⇒ Object 



794
795
796
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 794

def self.conv2_d_backprop_input(input_sizes, filter, out_backprop, typeT: nil, strides: nil, use_cudnn_on_gpu: true, padding: nil, explicit_paddings: [], data_format: "NHWC", dilations: [], name: "Conv2DBackpropInput")
  self.execute("Conv2DBackpropInput", [input_sizes, filter, out_backprop], T: typeT, strides: strides, use_cudnn_on_gpu: use_cudnn_on_gpu, padding: padding, explicit_paddings: explicit_paddings, data_format: data_format, dilations: dilations, name: name)
end

.conv3_d(input, filter, typeT: nil, strides: nil, padding: nil, data_format: "NDHWC", dilations: [], name: "Conv3D") ⇒ Object 



798
799
800
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 798

def self.conv3_d(input, filter, typeT: nil, strides: nil, padding: nil, data_format: "NDHWC", dilations: [], name: "Conv3D")
  self.execute("Conv3D", [input, filter], T: typeT, strides: strides, padding: padding, data_format: data_format, dilations: dilations, name: name)
end

.conv3_d_backprop_filter(input, filter, out_backprop, typeT: nil, strides: nil, padding: nil, dilations: [], name: "Conv3DBackpropFilter") ⇒ Object 



802
803
804
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 802

def self.conv3_d_backprop_filter(input, filter, out_backprop, typeT: nil, strides: nil, padding: nil, dilations: [], name: "Conv3DBackpropFilter")
  self.execute("Conv3DBackpropFilter", [input, filter, out_backprop], T: typeT, strides: strides, padding: padding, dilations: dilations, name: name)
end

.conv3_d_backprop_filter_v2(input, filter_sizes, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NDHWC", dilations: [], name: "Conv3DBackpropFilterV2") ⇒ Object 



806
807
808
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 806

def self.conv3_d_backprop_filter_v2(input, filter_sizes, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NDHWC", dilations: [], name: "Conv3DBackpropFilterV2")
  self.execute("Conv3DBackpropFilterV2", [input, filter_sizes, out_backprop], T: typeT, strides: strides, padding: padding, data_format: data_format, dilations: dilations, name: name)
end

.conv3_d_backprop_input(input, filter, out_backprop, typeT: nil, strides: nil, padding: nil, dilations: [], name: "Conv3DBackpropInput") ⇒ Object 



810
811
812
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 810

def self.conv3_d_backprop_input(input, filter, out_backprop, typeT: nil, strides: nil, padding: nil, dilations: [], name: "Conv3DBackpropInput")
  self.execute("Conv3DBackpropInput", [input, filter, out_backprop], T: typeT, strides: strides, padding: padding, dilations: dilations, name: name)
end

.conv3_d_backprop_input_v2(input_sizes, filter, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NDHWC", dilations: [], tshape: :int32, name: "Conv3DBackpropInputV2") ⇒ Object 



814
815
816
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 814

def self.conv3_d_backprop_input_v2(input_sizes, filter, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NDHWC", dilations: [], tshape: :int32, name: "Conv3DBackpropInputV2")
  self.execute("Conv3DBackpropInputV2", [input_sizes, filter, out_backprop], T: typeT, strides: strides, padding: padding, data_format: data_format, dilations: dilations, Tshape: tshape, name: name)
end

.copy(input, typeT: nil, tensor_name: "", debug_ops_spec: [], name: "Copy") ⇒ Object 



818
819
820
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 818

def self.copy(input, typeT: nil, tensor_name: "", debug_ops_spec: [], name: "Copy")
  self.execute("Copy", [input], T: typeT, tensor_name: tensor_name, debug_ops_spec: debug_ops_spec, name: name)
end

.copy_host(input, typeT: nil, tensor_name: "", debug_ops_spec: [], name: "CopyHost") ⇒ Object 



822
823
824
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 822

def self.copy_host(input, typeT: nil, tensor_name: "", debug_ops_spec: [], name: "CopyHost")
  self.execute("CopyHost", [input], T: typeT, tensor_name: tensor_name, debug_ops_spec: debug_ops_spec, name: name)
end

.cos(x, typeT: nil, name: "Cos") ⇒ Object 



826
827
828
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 826

def self.cos(x, typeT: nil, name: "Cos")
  self.execute("Cos", [x], T: typeT, name: name)
end

.cosh(x, typeT: nil, name: "Cosh") ⇒ Object 



830
831
832
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 830

def self.cosh(x, typeT: nil, name: "Cosh")
  self.execute("Cosh", [x], T: typeT, name: name)
end

.count_up_to(ref, limit: nil, typeT: nil, name: "CountUpTo") ⇒ Object 



834
835
836
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 834

def self.count_up_to(ref, limit: nil, typeT: nil, name: "CountUpTo")
  self.execute("CountUpTo", [ref], limit: limit, T: typeT, name: name)
end

.create_summary_db_writer(writer, db_uri, experiment_name, run_name, user_name, name: "CreateSummaryDbWriter") ⇒ Object 



838
839
840
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 838

def self.create_summary_db_writer(writer, db_uri, experiment_name, run_name, user_name, name: "CreateSummaryDbWriter")
  self.execute("CreateSummaryDbWriter", [writer, db_uri, experiment_name, run_name, user_name], name: name)
end

.create_summary_file_writer(writer, logdir, max_queue, flush_millis, filename_suffix, name: "CreateSummaryFileWriter") ⇒ Object 



842
843
844
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 842

def self.create_summary_file_writer(writer, logdir, max_queue, flush_millis, filename_suffix, name: "CreateSummaryFileWriter")
  self.execute("CreateSummaryFileWriter", [writer, logdir, max_queue, flush_millis, filename_suffix], name: name)
end

.crop_and_resize(image, boxes, box_ind, crop_size, typeT: nil, method: "bilinear", extrapolation_value: 0.0, name: "CropAndResize") ⇒ Object 



846
847
848
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 846

def self.crop_and_resize(image, boxes, box_ind, crop_size, typeT: nil, method: "bilinear", extrapolation_value: 0.0, name: "CropAndResize")
  self.execute("CropAndResize", [image, boxes, box_ind, crop_size], T: typeT, method: method, extrapolation_value: extrapolation_value, name: name)
end

.crop_and_resize_grad_boxes(grads, image, boxes, box_ind, typeT: nil, method: "bilinear", name: "CropAndResizeGradBoxes") ⇒ Object 



850
851
852
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 850

def self.crop_and_resize_grad_boxes(grads, image, boxes, box_ind, typeT: nil, method: "bilinear", name: "CropAndResizeGradBoxes")
  self.execute("CropAndResizeGradBoxes", [grads, image, boxes, box_ind], T: typeT, method: method, name: name)
end

.crop_and_resize_grad_image(grads, boxes, box_ind, image_size, typeT: nil, method: "bilinear", name: "CropAndResizeGradImage") ⇒ Object 



854
855
856
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 854

def self.crop_and_resize_grad_image(grads, boxes, box_ind, image_size, typeT: nil, method: "bilinear", name: "CropAndResizeGradImage")
  self.execute("CropAndResizeGradImage", [grads, boxes, box_ind, image_size], T: typeT, method: method, name: name)
end

.cross(a, b, typeT: nil, name: "Cross") ⇒ Object 



858
859
860
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 858

def self.cross(a, b, typeT: nil, name: "Cross")
  self.execute("Cross", [a, b], T: typeT, name: name)
end

.cross_replica_sum(input, group_assignment, typeT: nil, name: "CrossReplicaSum") ⇒ Object 



862
863
864
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 862

def self.cross_replica_sum(input, group_assignment, typeT: nil, name: "CrossReplicaSum")
  self.execute("CrossReplicaSum", [input, group_assignment], T: typeT, name: name)
end

.csr_sparse_matrix_components(csr_sparse_matrix, index, type: nil, name: "CSRSparseMatrixComponents") ⇒ Object 



622
623
624
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 622

def self.csr_sparse_matrix_components(csr_sparse_matrix, index, type: nil, name: "CSRSparseMatrixComponents")
  self.execute("CSRSparseMatrixComponents", [csr_sparse_matrix, index], type: type, name: name)
end

.csr_sparse_matrix_to_dense(sparse_input, type: nil, name: "CSRSparseMatrixToDense") ⇒ Object 



626
627
628
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 626

def self.csr_sparse_matrix_to_dense(sparse_input, type: nil, name: "CSRSparseMatrixToDense")
  self.execute("CSRSparseMatrixToDense", [sparse_input], type: type, name: name)
end

.csr_sparse_matrix_to_sparse_tensor(sparse_matrix, type: nil, name: "CSRSparseMatrixToSparseTensor") ⇒ Object 



630
631
632
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 630

def self.csr_sparse_matrix_to_sparse_tensor(sparse_matrix, type: nil, name: "CSRSparseMatrixToSparseTensor")
  self.execute("CSRSparseMatrixToSparseTensor", [sparse_matrix], type: type, name: name)
end

.csv_dataset(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, output_types: nil, output_shapes: nil, name: "CSVDataset") ⇒ Object 



634
635
636
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 634

def self.csv_dataset(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, output_types: nil, output_shapes: nil, name: "CSVDataset")
  self.execute("CSVDataset", [filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults], output_types: output_types, output_shapes: output_shapes, name: name)
end

.ctc_beam_search_decoder(inputs, sequence_length, beam_width: nil, top_paths: nil, merge_repeated: true, typeT: :float, name: "CTCBeamSearchDecoder") ⇒ Object 



638
639
640
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 638

def self.ctc_beam_search_decoder(inputs, sequence_length, beam_width: nil, top_paths: nil, merge_repeated: true, typeT: :float, name: "CTCBeamSearchDecoder")
  self.execute("CTCBeamSearchDecoder", [inputs, sequence_length], beam_width: beam_width, top_paths: top_paths, merge_repeated: merge_repeated, T: typeT, name: name)
end

.ctc_greedy_decoder(inputs, sequence_length, merge_repeated: false, typeT: :float, name: "CTCGreedyDecoder") ⇒ Object 



642
643
644
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 642

def self.ctc_greedy_decoder(inputs, sequence_length, merge_repeated: false, typeT: :float, name: "CTCGreedyDecoder")
  self.execute("CTCGreedyDecoder", [inputs, sequence_length], merge_repeated: merge_repeated, T: typeT, name: name)
end

.ctc_loss(inputs, labels_indices, labels_values, sequence_length, preprocess_collapse_repeated: false, ctc_merge_repeated: true, ignore_longer_outputs_than_inputs: false, typeT: :float, name: "CTCLoss") ⇒ Object 



646
647
648
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 646

def self.ctc_loss(inputs, labels_indices, labels_values, sequence_length, preprocess_collapse_repeated: false, ctc_merge_repeated: true, ignore_longer_outputs_than_inputs: false, typeT: :float, name: "CTCLoss")
  self.execute("CTCLoss", [inputs, labels_indices, labels_values, sequence_length], preprocess_collapse_repeated: preprocess_collapse_repeated, ctc_merge_repeated: ctc_merge_repeated, ignore_longer_outputs_than_inputs: ignore_longer_outputs_than_inputs, T: typeT, name: name)
end

.cudnn_rnn(input, input_h, input_c, params, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, is_training: true, name: "CudnnRNN") ⇒ Object 



866
867
868
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 866

def self.cudnn_rnn(input, input_h, input_c, params, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, is_training: true, name: "CudnnRNN")
  self.execute("CudnnRNN", [input, input_h, input_c, params], T: typeT, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, is_training: is_training, name: name)
end

.cudnn_rnn_backprop(input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNBackprop") ⇒ Object 



870
871
872
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 870

def self.cudnn_rnn_backprop(input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNBackprop")
  self.execute("CudnnRNNBackprop", [input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space], T: typeT, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, name: name)
end

.cudnn_rnn_backprop_v2(input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNBackpropV2") ⇒ Object 



874
875
876
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 874

def self.cudnn_rnn_backprop_v2(input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNBackpropV2")
  self.execute("CudnnRNNBackpropV2", [input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved], T: typeT, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, name: name)
end

.cudnn_rnn_backprop_v3(input, input_h, input_c, params, sequence_lengths, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, time_major: true, name: "CudnnRNNBackpropV3") ⇒ Object 



878
879
880
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 878

def self.cudnn_rnn_backprop_v3(input, input_h, input_c, params, sequence_lengths, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, time_major: true, name: "CudnnRNNBackpropV3")
  self.execute("CudnnRNNBackpropV3", [input, input_h, input_c, params, sequence_lengths, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved], T: typeT, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, num_proj: num_proj, time_major: time_major, name: name)
end

.cudnn_rnn_canonical_to_params(num_layers, num_units, input_size, weights, biases, typeT: nil, num_params: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNCanonicalToParams") ⇒ Object 



882
883
884
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 882

def self.cudnn_rnn_canonical_to_params(num_layers, num_units, input_size, weights, biases, typeT: nil, num_params: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNCanonicalToParams")
  self.execute("CudnnRNNCanonicalToParams", [num_layers, num_units, input_size, weights, biases], T: typeT, num_params: num_params, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, name: name)
end

.cudnn_rnn_canonical_to_params_v2(num_layers, num_units, input_size, weights, biases, typeT: nil, num_params_weights: nil, num_params_biases: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, name: "CudnnRNNCanonicalToParamsV2") ⇒ Object 



886
887
888
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 886

def self.cudnn_rnn_canonical_to_params_v2(num_layers, num_units, input_size, weights, biases, typeT: nil, num_params_weights: nil, num_params_biases: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, name: "CudnnRNNCanonicalToParamsV2")
  self.execute("CudnnRNNCanonicalToParamsV2", [num_layers, num_units, input_size, weights, biases], T: typeT, num_params_weights: num_params_weights, num_params_biases: num_params_biases, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, num_proj: num_proj, name: name)
end

.cudnn_rnn_params_size(num_layers, num_units, input_size, typeT: nil, s: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, name: "CudnnRNNParamsSize") ⇒ Object 



890
891
892
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 890

def self.cudnn_rnn_params_size(num_layers, num_units, input_size, typeT: nil, s: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, name: "CudnnRNNParamsSize")
  self.execute("CudnnRNNParamsSize", [num_layers, num_units, input_size], T: typeT, S: s, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, num_proj: num_proj, name: name)
end

.cudnn_rnn_params_to_canonical(num_layers, num_units, input_size, params, typeT: nil, num_params: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNParamsToCanonical") ⇒ Object 



894
895
896
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 894

def self.cudnn_rnn_params_to_canonical(num_layers, num_units, input_size, params, typeT: nil, num_params: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, name: "CudnnRNNParamsToCanonical")
  self.execute("CudnnRNNParamsToCanonical", [num_layers, num_units, input_size, params], T: typeT, num_params: num_params, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, name: name)
end

.cudnn_rnn_params_to_canonical_v2(num_layers, num_units, input_size, params, typeT: nil, num_params_weights: nil, num_params_biases: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, name: "CudnnRNNParamsToCanonicalV2") ⇒ Object 



898
899
900
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 898

def self.cudnn_rnn_params_to_canonical_v2(num_layers, num_units, input_size, params, typeT: nil, num_params_weights: nil, num_params_biases: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, name: "CudnnRNNParamsToCanonicalV2")
  self.execute("CudnnRNNParamsToCanonicalV2", [num_layers, num_units, input_size, params], T: typeT, num_params_weights: num_params_weights, num_params_biases: num_params_biases, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, num_proj: num_proj, name: name)
end

.cudnn_rnnv2(input, input_h, input_c, params, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, is_training: true, name: "CudnnRNNV2") ⇒ Object 



902
903
904
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 902

def self.cudnn_rnnv2(input, input_h, input_c, params, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, is_training: true, name: "CudnnRNNV2")
  self.execute("CudnnRNNV2", [input, input_h, input_c, params], T: typeT, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, is_training: is_training, name: name)
end

.cudnn_rnnv3(input, input_h, input_c, params, sequence_lengths, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, is_training: true, time_major: true, name: "CudnnRNNV3") ⇒ Object 



906
907
908
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 906

def self.cudnn_rnnv3(input, input_h, input_c, params, sequence_lengths, typeT: nil, rnn_mode: "lstm", input_mode: "linear_input", direction: "unidirectional", dropout: 0.0, seed: 0, seed2: 0, num_proj: 0, is_training: true, time_major: true, name: "CudnnRNNV3")
  self.execute("CudnnRNNV3", [input, input_h, input_c, params, sequence_lengths], T: typeT, rnn_mode: rnn_mode, input_mode: input_mode, direction: direction, dropout: dropout, seed: seed, seed2: seed2, num_proj: num_proj, is_training: is_training, time_major: time_major, name: name)
end

.cumprod(x, axis, exclusive: false, reverse: false, typeT: nil, tidx: :int32, name: "Cumprod") ⇒ Object 



910
911
912
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 910

def self.cumprod(x, axis, exclusive: false, reverse: false, typeT: nil, tidx: :int32, name: "Cumprod")
  self.execute("Cumprod", [x, axis], exclusive: exclusive, reverse: reverse, T: typeT, Tidx: tidx, name: name)
end

.cumsum(x, axis, exclusive: false, reverse: false, typeT: nil, tidx: :int32, name: "Cumsum") ⇒ Object 



914
915
916
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 914

def self.cumsum(x, axis, exclusive: false, reverse: false, typeT: nil, tidx: :int32, name: "Cumsum")
  self.execute("Cumsum", [x, axis], exclusive: exclusive, reverse: reverse, T: typeT, Tidx: tidx, name: name)
end

.cumulative_logsumexp(x, axis, exclusive: false, reverse: false, typeT: nil, tidx: :int32, name: "CumulativeLogsumexp") ⇒ Object 



918
919
920
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 918

def self.cumulative_logsumexp(x, axis, exclusive: false, reverse: false, typeT: nil, tidx: :int32, name: "CumulativeLogsumexp")
  self.execute("CumulativeLogsumexp", [x, axis], exclusive: exclusive, reverse: reverse, T: typeT, Tidx: tidx, name: name)
end

.data_format_dim_map(x, typeT: :int32, src_format: "NHWC", dst_format: "NCHW", name: "DataFormatDimMap") ⇒ Object 



922
923
924
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 922

def self.data_format_dim_map(x, typeT: :int32, src_format: "NHWC", dst_format: "NCHW", name: "DataFormatDimMap")
  self.execute("DataFormatDimMap", [x], T: typeT, src_format: src_format, dst_format: dst_format, name: name)
end

.data_format_vec_permute(x, typeT: :int32, src_format: "NHWC", dst_format: "NCHW", name: "DataFormatVecPermute") ⇒ Object 



926
927
928
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 926

def self.data_format_vec_permute(x, typeT: :int32, src_format: "NHWC", dst_format: "NCHW", name: "DataFormatVecPermute")
  self.execute("DataFormatVecPermute", [x], T: typeT, src_format: src_format, dst_format: dst_format, name: name)
end

.dataset_cardinality(input_dataset, name: "DatasetCardinality") ⇒ Object 



930
931
932
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 930

def self.dataset_cardinality(input_dataset, name: "DatasetCardinality")
  self.execute("DatasetCardinality", [input_dataset], name: name)
end

.dataset_from_graph(graph_def, name: "DatasetFromGraph") ⇒ Object 



934
935
936
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 934

def self.dataset_from_graph(graph_def, name: "DatasetFromGraph")
  self.execute("DatasetFromGraph", [graph_def], name: name)
end

.dataset_to_graph(input_dataset, stateful_whitelist: [], allow_stateful: false, strip_device_assignment: false, name: "DatasetToGraph") ⇒ Object 



938
939
940
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 938

def self.dataset_to_graph(input_dataset, stateful_whitelist: [], allow_stateful: false, strip_device_assignment: false, name: "DatasetToGraph")
  self.execute("DatasetToGraph", [input_dataset], stateful_whitelist: stateful_whitelist, allow_stateful: allow_stateful, strip_device_assignment: strip_device_assignment, name: name)
end

.dataset_to_graph_v2(input_dataset, external_state_policy: 0, strip_device_assignment: false, name: "DatasetToGraphV2") ⇒ Object 



942
943
944
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 942

def self.dataset_to_graph_v2(input_dataset, external_state_policy: 0, strip_device_assignment: false, name: "DatasetToGraphV2")
  self.execute("DatasetToGraphV2", [input_dataset], external_state_policy: external_state_policy, strip_device_assignment: strip_device_assignment, name: name)
end

.dataset_to_single_element(dataset, output_types: nil, output_shapes: nil, name: "DatasetToSingleElement") ⇒ Object 



946
947
948
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 946

def self.dataset_to_single_element(dataset, output_types: nil, output_shapes: nil, name: "DatasetToSingleElement")
  self.execute("DatasetToSingleElement", [dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.dataset_to_tf_record(input_dataset, filename, compression_type, name: "DatasetToTFRecord") ⇒ Object 



950
951
952
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 950

def self.dataset_to_tf_record(input_dataset, filename, compression_type, name: "DatasetToTFRecord")
  self.execute("DatasetToTFRecord", [input_dataset, filename, compression_type], name: name)
end

.debug_gradient_identity(input, typeT: nil, name: "DebugGradientIdentity") ⇒ Object 



954
955
956
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 954

def self.debug_gradient_identity(input, typeT: nil, name: "DebugGradientIdentity")
  self.execute("DebugGradientIdentity", [input], T: typeT, name: name)
end

.debug_gradient_ref_identity(input, typeT: nil, name: "DebugGradientRefIdentity") ⇒ Object 



958
959
960
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 958

def self.debug_gradient_ref_identity(input, typeT: nil, name: "DebugGradientRefIdentity")
  self.execute("DebugGradientRefIdentity", [input], T: typeT, name: name)
end

.debug_identity(input, typeT: nil, device_name: "", tensor_name: "", debug_urls: [], gated_grpc: false, name: "DebugIdentity") ⇒ Object 



962
963
964
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 962

def self.debug_identity(input, typeT: nil, device_name: "", tensor_name: "", debug_urls: [], gated_grpc: false, name: "DebugIdentity")
  self.execute("DebugIdentity", [input], T: typeT, device_name: device_name, tensor_name: tensor_name, debug_urls: debug_urls, gated_grpc: gated_grpc, name: name)
end

.debug_identity_v2(input, typeT: nil, tfdbg_context_id: "", op_name: "", output_slot: -1,, tensor_debug_mode: -1,, debug_urls: [], name: "DebugIdentityV2") ⇒ Object 



966
967
968
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 966

def self.debug_identity_v2(input, typeT: nil, tfdbg_context_id: "", op_name: "", output_slot: -1, tensor_debug_mode: -1, debug_urls: [], name: "DebugIdentityV2")
  self.execute("DebugIdentityV2", [input], T: typeT, tfdbg_context_id: tfdbg_context_id, op_name: op_name, output_slot: output_slot, tensor_debug_mode: tensor_debug_mode, debug_urls: debug_urls, name: name)
end

.debug_nan_count(input, typeT: nil, device_name: "", tensor_name: "", debug_urls: [], gated_grpc: false, name: "DebugNanCount") ⇒ Object 



970
971
972
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 970

def self.debug_nan_count(input, typeT: nil, device_name: "", tensor_name: "", debug_urls: [], gated_grpc: false, name: "DebugNanCount")
  self.execute("DebugNanCount", [input], T: typeT, device_name: device_name, tensor_name: tensor_name, debug_urls: debug_urls, gated_grpc: gated_grpc, name: name)
end

.debug_numeric_summary(input, typeT: nil, device_name: "", tensor_name: "", debug_urls: [], lower_bound: -Infinity,, upper_bound: Infinity, mute_if_healthy: false, gated_grpc: false, name: "DebugNumericSummary") ⇒ Object 



974
975
976
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 974

def self.debug_numeric_summary(input, typeT: nil, device_name: "", tensor_name: "", debug_urls: [], lower_bound: -Infinity, upper_bound: Infinity, mute_if_healthy: false, gated_grpc: false, name: "DebugNumericSummary")
  self.execute("DebugNumericSummary", [input], T: typeT, device_name: device_name, tensor_name: tensor_name, debug_urls: debug_urls, lower_bound: lower_bound, upper_bound: upper_bound, mute_if_healthy: mute_if_healthy, gated_grpc: gated_grpc, name: name)
end

.decode_and_crop_jpeg(contents, crop_window, channels: 0, ratio: 1, fancy_upscaling: true, try_recover_truncated: false, acceptable_fraction: 1.0, dct_method: "", name: "DecodeAndCropJpeg") ⇒ Object 



978
979
980
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 978

def self.decode_and_crop_jpeg(contents, crop_window, channels: 0, ratio: 1, fancy_upscaling: true, try_recover_truncated: false, acceptable_fraction: 1.0, dct_method: "", name: "DecodeAndCropJpeg")
  self.execute("DecodeAndCropJpeg", [contents, crop_window], channels: channels, ratio: ratio, fancy_upscaling: fancy_upscaling, try_recover_truncated: try_recover_truncated, acceptable_fraction: acceptable_fraction, dct_method: dct_method, name: name)
end

.decode_base64(input, name: "DecodeBase64") ⇒ Object 



982
983
984
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 982

def self.decode_base64(input, name: "DecodeBase64")
  self.execute("DecodeBase64", [input], name: name)
end

.decode_bmp(contents, channels: 0, name: "DecodeBmp") ⇒ Object 



986
987
988
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 986

def self.decode_bmp(contents, channels: 0, name: "DecodeBmp")
  self.execute("DecodeBmp", [contents], channels: channels, name: name)
end

.decode_compressed(bytes, compression_type: "", name: "DecodeCompressed") ⇒ Object 



994
995
996
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 994

def self.decode_compressed(bytes, compression_type: "", name: "DecodeCompressed")
  self.execute("DecodeCompressed", [bytes], compression_type: compression_type, name: name)
end

.decode_csv(records, record_defaults, out_type: nil, field_delim: ",", use_quote_delim: true, na_value: "", select_cols: [], name: "DecodeCSV") ⇒ Object 



990
991
992
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 990

def self.decode_csv(records, record_defaults, out_type: nil, field_delim: ",", use_quote_delim: true, na_value: "", select_cols: [], name: "DecodeCSV")
  self.execute("DecodeCSV", [records, record_defaults], OUT_TYPE: out_type, field_delim: field_delim, use_quote_delim: use_quote_delim, na_value: na_value, select_cols: select_cols, name: name)
end

.decode_gif(contents, name: "DecodeGif") ⇒ Object 



998
999
1000
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 998

def self.decode_gif(contents, name: "DecodeGif")
  self.execute("DecodeGif", [contents], name: name)
end

.decode_jpeg(contents, channels: 0, ratio: 1, fancy_upscaling: true, try_recover_truncated: false, acceptable_fraction: 1.0, dct_method: "", name: "DecodeJpeg") ⇒ Object 



1006
1007
1008
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1006

def self.decode_jpeg(contents, channels: 0, ratio: 1, fancy_upscaling: true, try_recover_truncated: false, acceptable_fraction: 1.0, dct_method: "", name: "DecodeJpeg")
  self.execute("DecodeJpeg", [contents], channels: channels, ratio: ratio, fancy_upscaling: fancy_upscaling, try_recover_truncated: try_recover_truncated, acceptable_fraction: acceptable_fraction, dct_method: dct_method, name: name)
end

.decode_json_example(json_examples, name: "DecodeJSONExample") ⇒ Object 



1002
1003
1004
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1002

def self.decode_json_example(json_examples, name: "DecodeJSONExample")
  self.execute("DecodeJSONExample", [json_examples], name: name)
end

.decode_padded_raw(input_bytes, fixed_length, out_type: nil, little_endian: true, name: "DecodePaddedRaw") ⇒ Object 



1010
1011
1012
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1010

def self.decode_padded_raw(input_bytes, fixed_length, out_type: nil, little_endian: true, name: "DecodePaddedRaw")
  self.execute("DecodePaddedRaw", [input_bytes, fixed_length], out_type: out_type, little_endian: little_endian, name: name)
end

.decode_png(contents, channels: 0, dtype: :uint8, name: "DecodePng") ⇒ Object 



1014
1015
1016
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1014

def self.decode_png(contents, channels: 0, dtype: :uint8, name: "DecodePng")
  self.execute("DecodePng", [contents], channels: channels, dtype: dtype, name: name)
end

.decode_proto_v2(bytes, message_type: "", field_names: nil, output_types: nil, descriptor_source: "local://", message_format: "binary", sanitize: false, name: "DecodeProtoV2") ⇒ Object 



1018
1019
1020
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1018

def self.decode_proto_v2(bytes, message_type: "", field_names: nil, output_types: nil, descriptor_source: "local://", message_format: "binary", sanitize: false, name: "DecodeProtoV2")
  self.execute("DecodeProtoV2", [bytes], message_type: message_type, field_names: field_names, output_types: output_types, descriptor_source: descriptor_source, message_format: message_format, sanitize: sanitize, name: name)
end

.decode_raw(bytes, out_type: nil, little_endian: true, name: "DecodeRaw") ⇒ Object 



1022
1023
1024
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1022

def self.decode_raw(bytes, out_type: nil, little_endian: true, name: "DecodeRaw")
  self.execute("DecodeRaw", [bytes], out_type: out_type, little_endian: little_endian, name: name)
end

.decode_wav(contents, desired_channels: -1,, desired_samples: -1,, name: "DecodeWav") ⇒ Object 



1026
1027
1028
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1026

def self.decode_wav(contents, desired_channels: -1, desired_samples: -1, name: "DecodeWav")
  self.execute("DecodeWav", [contents], desired_channels: desired_channels, desired_samples: desired_samples, name: name)
end

.deep_copy(x, typeT: nil, name: "DeepCopy") ⇒ Object 



1030
1031
1032
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1030

def self.deep_copy(x, typeT: nil, name: "DeepCopy")
  self.execute("DeepCopy", [x], T: typeT, name: name)
end

.delete_iterator(handle, deleter, name: "DeleteIterator") ⇒ Object 



1034
1035
1036
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1034

def self.delete_iterator(handle, deleter, name: "DeleteIterator")
  self.execute("DeleteIterator", [handle, deleter], name: name)
end

.delete_memory_cache(handle, deleter, name: "DeleteMemoryCache") ⇒ Object 



1038
1039
1040
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1038

def self.delete_memory_cache(handle, deleter, name: "DeleteMemoryCache")
  self.execute("DeleteMemoryCache", [handle, deleter], name: name)
end

.delete_multi_device_iterator(multi_device_iterator, iterators, deleter, n: nil, name: "DeleteMultiDeviceIterator") ⇒ Object 



1042
1043
1044
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1042

def self.delete_multi_device_iterator(multi_device_iterator, iterators, deleter, n: nil, name: "DeleteMultiDeviceIterator")
  self.execute("DeleteMultiDeviceIterator", [multi_device_iterator, iterators, deleter], N: n, name: name)
end

.delete_random_seed_generator(handle, deleter, name: "DeleteRandomSeedGenerator") ⇒ Object 



1046
1047
1048
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1046

def self.delete_random_seed_generator(handle, deleter, name: "DeleteRandomSeedGenerator")
  self.execute("DeleteRandomSeedGenerator", [handle, deleter], name: name)
end

.delete_session_tensor(handle, name: "DeleteSessionTensor") ⇒ Object 



1050
1051
1052
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1050

def self.delete_session_tensor(handle, name: "DeleteSessionTensor")
  self.execute("DeleteSessionTensor", [handle], name: name)
end

.dense_to_csr_sparse_matrix(dense_input, indices, typeT: nil, name: "DenseToCSRSparseMatrix") ⇒ Object 



1054
1055
1056
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1054

def self.dense_to_csr_sparse_matrix(dense_input, indices, typeT: nil, name: "DenseToCSRSparseMatrix")
  self.execute("DenseToCSRSparseMatrix", [dense_input, indices], T: typeT, name: name)
end

.dense_to_dense_set_operation(set1, set2, set_operation: "", validate_indices: true, typeT: nil, name: "DenseToDenseSetOperation") ⇒ Object 



1058
1059
1060
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1058

def self.dense_to_dense_set_operation(set1, set2, set_operation: "", validate_indices: true, typeT: nil, name: "DenseToDenseSetOperation")
  self.execute("DenseToDenseSetOperation", [set1, set2], set_operation: set_operation, validate_indices: validate_indices, T: typeT, name: name)
end

.dense_to_sparse_batch_dataset(input_dataset, batch_size, row_shape, output_types: nil, output_shapes: nil, name: "DenseToSparseBatchDataset") ⇒ Object 



1062
1063
1064
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1062

def self.dense_to_sparse_batch_dataset(input_dataset, batch_size, row_shape, output_types: nil, output_shapes: nil, name: "DenseToSparseBatchDataset")
  self.execute("DenseToSparseBatchDataset", [input_dataset, batch_size, row_shape], output_types: output_types, output_shapes: output_shapes, name: name)
end

.dense_to_sparse_set_operation(set1, set2_indices, set2_values, set2_shape, set_operation: "", validate_indices: true, typeT: nil, name: "DenseToSparseSetOperation") ⇒ Object 



1066
1067
1068
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1066

def self.dense_to_sparse_set_operation(set1, set2_indices, set2_values, set2_shape, set_operation: "", validate_indices: true, typeT: nil, name: "DenseToSparseSetOperation")
  self.execute("DenseToSparseSetOperation", [set1, set2_indices, set2_values, set2_shape], set_operation: set_operation, validate_indices: validate_indices, T: typeT, name: name)
end

.depth_to_space(input, typeT: nil, block_size: nil, data_format: "NHWC", name: "DepthToSpace") ⇒ Object 



1070
1071
1072
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1070

def self.depth_to_space(input, typeT: nil, block_size: nil, data_format: "NHWC", name: "DepthToSpace")
  self.execute("DepthToSpace", [input], T: typeT, block_size: block_size, data_format: data_format, name: name)
end

.depthwise_conv2d_native(input, filter, typeT: nil, strides: nil, padding: nil, data_format: "NHWC", dilations: [], name: "DepthwiseConv2dNative") ⇒ Object 



1074
1075
1076
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1074

def self.depthwise_conv2d_native(input, filter, typeT: nil, strides: nil, padding: nil, data_format: "NHWC", dilations: [], name: "DepthwiseConv2dNative")
  self.execute("DepthwiseConv2dNative", [input, filter], T: typeT, strides: strides, padding: padding, data_format: data_format, dilations: dilations, name: name)
end

.depthwise_conv2d_native_backprop_filter(input, filter_sizes, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NHWC", dilations: [], name: "DepthwiseConv2dNativeBackpropFilter") ⇒ Object 



1078
1079
1080
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1078

def self.depthwise_conv2d_native_backprop_filter(input, filter_sizes, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NHWC", dilations: [], name: "DepthwiseConv2dNativeBackpropFilter")
  self.execute("DepthwiseConv2dNativeBackpropFilter", [input, filter_sizes, out_backprop], T: typeT, strides: strides, padding: padding, data_format: data_format, dilations: dilations, name: name)
end

.depthwise_conv2d_native_backprop_input(input_sizes, filter, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NHWC", dilations: [], name: "DepthwiseConv2dNativeBackpropInput") ⇒ Object 



1082
1083
1084
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1082

def self.depthwise_conv2d_native_backprop_input(input_sizes, filter, out_backprop, typeT: nil, strides: nil, padding: nil, data_format: "NHWC", dilations: [], name: "DepthwiseConv2dNativeBackpropInput")
  self.execute("DepthwiseConv2dNativeBackpropInput", [input_sizes, filter, out_backprop], T: typeT, strides: strides, padding: padding, data_format: data_format, dilations: dilations, name: name)
end

.dequantize(input, min_range, max_range, typeT: nil, mode: "MIN_COMBINED", narrow_range: false, axis: -1,, name: "Dequantize") ⇒ Object 



1086
1087
1088
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1086

def self.dequantize(input, min_range, max_range, typeT: nil, mode: "MIN_COMBINED", narrow_range: false, axis: -1, name: "Dequantize")
  self.execute("Dequantize", [input, min_range, max_range], T: typeT, mode: mode, narrow_range: narrow_range, axis: axis, name: name)
end

.deserialize_iterator(resource_handle, serialized, name: "DeserializeIterator") ⇒ Object 



1090
1091
1092
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1090

def self.deserialize_iterator(resource_handle, serialized, name: "DeserializeIterator")
  self.execute("DeserializeIterator", [resource_handle, serialized], name: name)
end

.deserialize_many_sparse(serialized_sparse, dtype: nil, name: "DeserializeManySparse") ⇒ Object 



1094
1095
1096
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1094

def self.deserialize_many_sparse(serialized_sparse, dtype: nil, name: "DeserializeManySparse")
  self.execute("DeserializeManySparse", [serialized_sparse], dtype: dtype, name: name)
end

.deserialize_sparse(serialized_sparse, dtype: nil, tserialized: :string, name: "DeserializeSparse") ⇒ Object 



1098
1099
1100
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1098

def self.deserialize_sparse(serialized_sparse, dtype: nil, tserialized: :string, name: "DeserializeSparse")
  self.execute("DeserializeSparse", [serialized_sparse], dtype: dtype, Tserialized: tserialized, name: name)
end

.destroy_resource_op(resource, ignore_lookup_error: true, name: "DestroyResourceOp") ⇒ Object 



1102
1103
1104
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1102

def self.destroy_resource_op(resource, ignore_lookup_error: true, name: "DestroyResourceOp")
  self.execute("DestroyResourceOp", [resource], ignore_lookup_error: ignore_lookup_error, name: name)
end

.destroy_temporary_variable(ref, typeT: nil, var_name: "", name: "DestroyTemporaryVariable") ⇒ Object 



1106
1107
1108
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1106

def self.destroy_temporary_variable(ref, typeT: nil, var_name: "", name: "DestroyTemporaryVariable")
  self.execute("DestroyTemporaryVariable", [ref], T: typeT, var_name: var_name, name: name)
end

.diag(diagonal, typeT: nil, name: "Diag") ⇒ Object 



1110
1111
1112
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1110

def self.diag(diagonal, typeT: nil, name: "Diag")
  self.execute("Diag", [diagonal], T: typeT, name: name)
end

.diag_part(input, typeT: nil, name: "DiagPart") ⇒ Object 



1114
1115
1116
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1114

def self.diag_part(input, typeT: nil, name: "DiagPart")
  self.execute("DiagPart", [input], T: typeT, name: name)
end

.digamma(x, typeT: nil, name: "Digamma") ⇒ Object 



1118
1119
1120
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1118

def self.digamma(x, typeT: nil, name: "Digamma")
  self.execute("Digamma", [x], T: typeT, name: name)
end

.dilation2_d(input, filter, typeT: nil, strides: nil, rates: nil, padding: nil, name: "Dilation2D") ⇒ Object 



1122
1123
1124
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1122

def self.dilation2_d(input, filter, typeT: nil, strides: nil, rates: nil, padding: nil, name: "Dilation2D")
  self.execute("Dilation2D", [input, filter], T: typeT, strides: strides, rates: rates, padding: padding, name: name)
end

.dilation2_d_backprop_filter(input, filter, out_backprop, typeT: nil, strides: nil, rates: nil, padding: nil, name: "Dilation2DBackpropFilter") ⇒ Object 



1126
1127
1128
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1126

def self.dilation2_d_backprop_filter(input, filter, out_backprop, typeT: nil, strides: nil, rates: nil, padding: nil, name: "Dilation2DBackpropFilter")
  self.execute("Dilation2DBackpropFilter", [input, filter, out_backprop], T: typeT, strides: strides, rates: rates, padding: padding, name: name)
end

.dilation2_d_backprop_input(input, filter, out_backprop, typeT: nil, strides: nil, rates: nil, padding: nil, name: "Dilation2DBackpropInput") ⇒ Object 



1130
1131
1132
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1130

def self.dilation2_d_backprop_input(input, filter, out_backprop, typeT: nil, strides: nil, rates: nil, padding: nil, name: "Dilation2DBackpropInput")
  self.execute("Dilation2DBackpropInput", [input, filter, out_backprop], T: typeT, strides: strides, rates: rates, padding: padding, name: name)
end

.directed_interleave_dataset(selector_input_dataset, data_input_datasets, output_types: nil, output_shapes: nil, n: nil, name: "DirectedInterleaveDataset") ⇒ Object 



1134
1135
1136
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1134

def self.directed_interleave_dataset(selector_input_dataset, data_input_datasets, output_types: nil, output_shapes: nil, n: nil, name: "DirectedInterleaveDataset")
  self.execute("DirectedInterleaveDataset", [selector_input_dataset, data_input_datasets], output_types: output_types, output_shapes: output_shapes, N: n, name: name)
end

.div(x, y, typeT: nil, name: "Div") ⇒ Object 



1138
1139
1140
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1138

def self.div(x, y, typeT: nil, name: "Div")
  self.execute("Div", [x, y], T: typeT, name: name)
end

.div_no_nan(x, y, typeT: nil, name: "DivNoNan") ⇒ Object 



1142
1143
1144
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1142

def self.div_no_nan(x, y, typeT: nil, name: "DivNoNan")
  self.execute("DivNoNan", [x, y], T: typeT, name: name)
end

.draw_bounding_boxes(images, boxes, typeT: :float, name: "DrawBoundingBoxes") ⇒ Object 



1146
1147
1148
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1146

def self.draw_bounding_boxes(images, boxes, typeT: :float, name: "DrawBoundingBoxes")
  self.execute("DrawBoundingBoxes", [images, boxes], T: typeT, name: name)
end

.draw_bounding_boxes_v2(images, boxes, colors, typeT: :float, name: "DrawBoundingBoxesV2") ⇒ Object 



1150
1151
1152
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1150

def self.draw_bounding_boxes_v2(images, boxes, colors, typeT: :float, name: "DrawBoundingBoxesV2")
  self.execute("DrawBoundingBoxesV2", [images, boxes, colors], T: typeT, name: name)
end

.dynamic_partition(data, partitions, num_partitions: nil, typeT: nil, name: "DynamicPartition") ⇒ Object 



1154
1155
1156
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1154

def self.dynamic_partition(data, partitions, num_partitions: nil, typeT: nil, name: "DynamicPartition")
  self.execute("DynamicPartition", [data, partitions], num_partitions: num_partitions, T: typeT, name: name)
end

.dynamic_stitch(indices, data, n: nil, typeT: nil, name: "DynamicStitch") ⇒ Object 



1158
1159
1160
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1158

def self.dynamic_stitch(indices, data, n: nil, typeT: nil, name: "DynamicStitch")
  self.execute("DynamicStitch", [indices, data], N: n, T: typeT, name: name)
end

.eager_py_func(input, token: "", is_async: false, tin: nil, tout: nil, name: "EagerPyFunc") ⇒ Object 



1162
1163
1164
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1162

def self.eager_py_func(input, token: "", is_async: false, tin: nil, tout: nil, name: "EagerPyFunc")
  self.execute("EagerPyFunc", [input], token: token, is_async: is_async, Tin: tin, Tout: tout, name: name)
end

.edit_distance(hypothesis_indices, hypothesis_values, hypothesis_shape, truth_indices, truth_values, truth_shape, normalize: true, typeT: nil, name: "EditDistance") ⇒ Object 



1166
1167
1168
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1166

def self.edit_distance(hypothesis_indices, hypothesis_values, hypothesis_shape, truth_indices, truth_values, truth_shape, normalize: true, typeT: nil, name: "EditDistance")
  self.execute("EditDistance", [hypothesis_indices, hypothesis_values, hypothesis_shape, truth_indices, truth_values, truth_shape], normalize: normalize, T: typeT, name: name)
end

.eig(input, compute_v: true, typeT: nil, tout: nil, name: "Eig") ⇒ Object 



1170
1171
1172
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1170

def self.eig(input, compute_v: true, typeT: nil, tout: nil, name: "Eig")
  self.execute("Eig", [input], compute_v: compute_v, T: typeT, Tout: tout, name: name)
end

.einsum(inputs, equation: "", n: nil, typeT: nil, name: "Einsum") ⇒ Object 



1174
1175
1176
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1174

def self.einsum(inputs, equation: "", n: nil, typeT: nil, name: "Einsum")
  self.execute("Einsum", [inputs], equation: equation, N: n, T: typeT, name: name)
end

.elu(features, typeT: nil, name: "Elu") ⇒ Object 



1178
1179
1180
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1178

def self.elu(features, typeT: nil, name: "Elu")
  self.execute("Elu", [features], T: typeT, name: name)
end

.elu_grad(gradients, outputs, typeT: nil, name: "EluGrad") ⇒ Object 



1182
1183
1184
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1182

def self.elu_grad(gradients, outputs, typeT: nil, name: "EluGrad")
  self.execute("EluGrad", [gradients, outputs], T: typeT, name: name)
end

.empty(shape, dtype: nil, init: false, name: "Empty") ⇒ Object 



1186
1187
1188
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1186

def self.empty(shape, dtype: nil, init: false, name: "Empty")
  self.execute("Empty", [shape], dtype: dtype, init: init, name: name)
end

.empty_tensor_list(element_shape, max_num_elements, element_dtype: nil, shape_type: nil, name: "EmptyTensorList") ⇒ Object 



1190
1191
1192
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1190

def self.empty_tensor_list(element_shape, max_num_elements, element_dtype: nil, shape_type: nil, name: "EmptyTensorList")
  self.execute("EmptyTensorList", [element_shape, max_num_elements], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.encode_base64(input, pad: false, name: "EncodeBase64") ⇒ Object 



1194
1195
1196
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1194

def self.encode_base64(input, pad: false, name: "EncodeBase64")
  self.execute("EncodeBase64", [input], pad: pad, name: name)
end

.encode_jpeg(image, format: "", quality: 95, progressive: false, optimize_size: false, chroma_downsampling: true, density_unit: "in", x_density: 300, y_density: 300, xmp_metadata: "", name: "EncodeJpeg") ⇒ Object 



1198
1199
1200
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1198

def self.encode_jpeg(image, format: "", quality: 95, progressive: false, optimize_size: false, chroma_downsampling: true, density_unit: "in", x_density: 300, y_density: 300, xmp_metadata: "", name: "EncodeJpeg")
  self.execute("EncodeJpeg", [image], format: format, quality: quality, progressive: progressive, optimize_size: optimize_size, chroma_downsampling: chroma_downsampling, density_unit: density_unit, x_density: x_density, y_density: y_density, xmp_metadata: xmp_metadata, name: name)
end

.encode_jpeg_variable_quality(images, quality, name: "EncodeJpegVariableQuality") ⇒ Object 



1202
1203
1204
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1202

def self.encode_jpeg_variable_quality(images, quality, name: "EncodeJpegVariableQuality")
  self.execute("EncodeJpegVariableQuality", [images, quality], name: name)
end

.encode_png(image, compression: -1,, typeT: :uint8, name: "EncodePng") ⇒ Object 



1206
1207
1208
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1206

def self.encode_png(image, compression: -1, typeT: :uint8, name: "EncodePng")
  self.execute("EncodePng", [image], compression: compression, T: typeT, name: name)
end

.encode_proto(sizes, values, field_names: nil, message_type: "", descriptor_source: "local://", tinput_types: nil, name: "EncodeProto") ⇒ Object 



1210
1211
1212
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1210

def self.encode_proto(sizes, values, field_names: nil, message_type: "", descriptor_source: "local://", tinput_types: nil, name: "EncodeProto")
  self.execute("EncodeProto", [sizes, values], field_names: field_names, message_type: message_type, descriptor_source: descriptor_source, Tinput_types: tinput_types, name: name)
end

.encode_wav(audio, sample_rate, name: "EncodeWav") ⇒ Object 



1214
1215
1216
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1214

def self.encode_wav(audio, sample_rate, name: "EncodeWav")
  self.execute("EncodeWav", [audio, sample_rate], name: name)
end

.enqueue_tpu_embedding_integer_batch(batch, mode_override, n: nil, device_ordinal: -1,, name: "EnqueueTPUEmbeddingIntegerBatch") ⇒ Object 



1218
1219
1220
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1218

def self.enqueue_tpu_embedding_integer_batch(batch, mode_override, n: nil, device_ordinal: -1, name: "EnqueueTPUEmbeddingIntegerBatch")
  self.execute("EnqueueTPUEmbeddingIntegerBatch", [batch, mode_override], N: n, device_ordinal: device_ordinal, name: name)
end

.enqueue_tpu_embedding_sparse_batch(sample_indices, embedding_indices, aggregation_weights, mode_override, t1: :int32, t2: :int32, t3: :float, n: nil, device_ordinal: -1,, combiners: [], name: "EnqueueTPUEmbeddingSparseBatch") ⇒ Object 



1222
1223
1224
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1222

def self.enqueue_tpu_embedding_sparse_batch(sample_indices, embedding_indices, aggregation_weights, mode_override, t1: :int32, t2: :int32, t3: :float, n: nil, device_ordinal: -1, combiners: [], name: "EnqueueTPUEmbeddingSparseBatch")
  self.execute("EnqueueTPUEmbeddingSparseBatch", [sample_indices, embedding_indices, aggregation_weights, mode_override], T1: t1, T2: t2, T3: t3, N: n, device_ordinal: device_ordinal, combiners: combiners, name: name)
end

.enqueue_tpu_embedding_sparse_tensor_batch(sample_indices, embedding_indices, aggregation_weights, mode_override, t1: :int32, t2: :int32, t3: :float, n: nil, device_ordinal: -1,, combiners: [], table_ids: nil, max_sequence_lengths: [], name: "EnqueueTPUEmbeddingSparseTensorBatch") ⇒ Object 



1226
1227
1228
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1226

def self.enqueue_tpu_embedding_sparse_tensor_batch(sample_indices, embedding_indices, aggregation_weights, mode_override, t1: :int32, t2: :int32, t3: :float, n: nil, device_ordinal: -1, combiners: [], table_ids: nil, max_sequence_lengths: [], name: "EnqueueTPUEmbeddingSparseTensorBatch")
  self.execute("EnqueueTPUEmbeddingSparseTensorBatch", [sample_indices, embedding_indices, aggregation_weights, mode_override], T1: t1, T2: t2, T3: t3, N: n, device_ordinal: device_ordinal, combiners: combiners, table_ids: table_ids, max_sequence_lengths: max_sequence_lengths, name: name)
end

.ensure_shape(input, shape: nil, typeT: nil, name: "EnsureShape") ⇒ Object 



1230
1231
1232
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1230

def self.ensure_shape(input, shape: nil, typeT: nil, name: "EnsureShape")
  self.execute("EnsureShape", [input], shape: shape, T: typeT, name: name)
end

.enter(data, typeT: nil, frame_name: "", is_constant: false, parallel_iterations: 10, name: "Enter") ⇒ Object 



1234
1235
1236
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1234

def self.enter(data, typeT: nil, frame_name: "", is_constant: false, parallel_iterations: 10, name: "Enter")
  self.execute("Enter", [data], T: typeT, frame_name: frame_name, is_constant: is_constant, parallel_iterations: parallel_iterations, name: name)
end

.equal(x, y, typeT: nil, incompatible_shape_error: true, name: "Equal") ⇒ Object 



1238
1239
1240
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1238

def self.equal(x, y, typeT: nil, incompatible_shape_error: true, name: "Equal")
  self.execute("Equal", [x, y], T: typeT, incompatible_shape_error: incompatible_shape_error, name: name)
end

.erf(x, typeT: nil, name: "Erf") ⇒ Object 



1242
1243
1244
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1242

def self.erf(x, typeT: nil, name: "Erf")
  self.execute("Erf", [x], T: typeT, name: name)
end

.erfc(x, typeT: nil, name: "Erfc") ⇒ Object 



1246
1247
1248
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1246

def self.erfc(x, typeT: nil, name: "Erfc")
  self.execute("Erfc", [x], T: typeT, name: name)
end

.erfinv(x, typeT: nil, name: "Erfinv") ⇒ Object 



1250
1251
1252
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1250

def self.erfinv(x, typeT: nil, name: "Erfinv")
  self.execute("Erfinv", [x], T: typeT, name: name)
end

.euclidean_norm(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "EuclideanNorm") ⇒ Object 



1254
1255
1256
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1254

def self.euclidean_norm(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "EuclideanNorm")
  self.execute("EuclideanNorm", [input, reduction_indices], keep_dims: keep_dims, T: typeT, Tidx: tidx, name: name)
end

.execute(op_type, inputs = [], attrs = {}) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5

def self.execute(op_type, inputs=[], attrs={})
  context = ExecutionContext.current(inputs)
  attrs = attrs.compact
  operation = context.create_operation(op_type, inputs, attrs)
  if context.is_a?(Graph::Graph)
    operation
  else
    context.execute(operation)
  end
end

.exit(data, typeT: nil, name: "Exit") ⇒ Object 



1258
1259
1260
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1258

def self.exit(data, typeT: nil, name: "Exit")
  self.execute("Exit", [data], T: typeT, name: name)
end

.exp(x, typeT: nil, name: "Exp") ⇒ Object 



1262
1263
1264
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1262

def self.exp(x, typeT: nil, name: "Exp")
  self.execute("Exp", [x], T: typeT, name: name)
end

.expand_dims(input, dim, typeT: nil, tdim: :int32, name: "ExpandDims") ⇒ Object 



1266
1267
1268
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1266

def self.expand_dims(input, dim, typeT: nil, tdim: :int32, name: "ExpandDims")
  self.execute("ExpandDims", [input, dim], T: typeT, Tdim: tdim, name: name)
end

.experimental_assert_next_dataset(input_dataset, transformations, output_types: nil, output_shapes: nil, name: "ExperimentalAssertNextDataset") ⇒ Object 



1270
1271
1272
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1270

def self.experimental_assert_next_dataset(input_dataset, transformations, output_types: nil, output_shapes: nil, name: "ExperimentalAssertNextDataset")
  self.execute("ExperimentalAssertNextDataset", [input_dataset, transformations], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_auto_shard_dataset(input_dataset, num_workers, index, auto_shard_policy: 0, output_types: nil, output_shapes: nil, name: "ExperimentalAutoShardDataset") ⇒ Object 



1274
1275
1276
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1274

def self.experimental_auto_shard_dataset(input_dataset, num_workers, index, auto_shard_policy: 0, output_types: nil, output_shapes: nil, name: "ExperimentalAutoShardDataset")
  self.execute("ExperimentalAutoShardDataset", [input_dataset, num_workers, index], auto_shard_policy: auto_shard_policy, output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_bytes_produced_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "ExperimentalBytesProducedStatsDataset") ⇒ Object 



1278
1279
1280
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1278

def self.experimental_bytes_produced_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "ExperimentalBytesProducedStatsDataset")
  self.execute("ExperimentalBytesProducedStatsDataset", [input_dataset, tag], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_choose_fastest_dataset(input_datasets, n: nil, num_experiments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalChooseFastestDataset") ⇒ Object 



1286
1287
1288
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1286

def self.experimental_choose_fastest_dataset(input_datasets, n: nil, num_experiments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalChooseFastestDataset")
  self.execute("ExperimentalChooseFastestDataset", [input_datasets], N: n, num_experiments: num_experiments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_csv_dataset(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, output_types: nil, output_shapes: nil, name: "ExperimentalCSVDataset") ⇒ Object 



1282
1283
1284
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1282

def self.experimental_csv_dataset(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, output_types: nil, output_shapes: nil, name: "ExperimentalCSVDataset")
  self.execute("ExperimentalCSVDataset", [filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_dataset_cardinality(input_dataset, name: "ExperimentalDatasetCardinality") ⇒ Object 



1290
1291
1292
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1290

def self.experimental_dataset_cardinality(input_dataset, name: "ExperimentalDatasetCardinality")
  self.execute("ExperimentalDatasetCardinality", [input_dataset], name: name)
end

.experimental_dataset_to_tf_record(input_dataset, filename, compression_type, name: "ExperimentalDatasetToTFRecord") ⇒ Object 



1294
1295
1296
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1294

def self.experimental_dataset_to_tf_record(input_dataset, filename, compression_type, name: "ExperimentalDatasetToTFRecord")
  self.execute("ExperimentalDatasetToTFRecord", [input_dataset, filename, compression_type], name: name)
end

.experimental_dense_to_sparse_batch_dataset(input_dataset, batch_size, row_shape, output_types: nil, output_shapes: nil, name: "ExperimentalDenseToSparseBatchDataset") ⇒ Object 



1298
1299
1300
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1298

def self.experimental_dense_to_sparse_batch_dataset(input_dataset, batch_size, row_shape, output_types: nil, output_shapes: nil, name: "ExperimentalDenseToSparseBatchDataset")
  self.execute("ExperimentalDenseToSparseBatchDataset", [input_dataset, batch_size, row_shape], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_directed_interleave_dataset(selector_input_dataset, data_input_datasets, output_types: nil, output_shapes: nil, n: nil, name: "ExperimentalDirectedInterleaveDataset") ⇒ Object 



1302
1303
1304
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1302

def self.experimental_directed_interleave_dataset(selector_input_dataset, data_input_datasets, output_types: nil, output_shapes: nil, n: nil, name: "ExperimentalDirectedInterleaveDataset")
  self.execute("ExperimentalDirectedInterleaveDataset", [selector_input_dataset, data_input_datasets], output_types: output_types, output_shapes: output_shapes, N: n, name: name)
end

.experimental_group_by_reducer_dataset(input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments, key_func: nil, init_func: nil, reduce_func: nil, finalize_func: nil, tkey_func_other_arguments: nil, tinit_func_other_arguments: nil, treduce_func_other_arguments: nil, tfinalize_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalGroupByReducerDataset") ⇒ Object 



1306
1307
1308
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1306

def self.experimental_group_by_reducer_dataset(input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments, key_func: nil, init_func: nil, reduce_func: nil, finalize_func: nil, tkey_func_other_arguments: nil, tinit_func_other_arguments: nil, treduce_func_other_arguments: nil, tfinalize_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalGroupByReducerDataset")
  self.execute("ExperimentalGroupByReducerDataset", [input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments], key_func: key_func, init_func: init_func, reduce_func: reduce_func, finalize_func: finalize_func, Tkey_func_other_arguments: tkey_func_other_arguments, Tinit_func_other_arguments: tinit_func_other_arguments, Treduce_func_other_arguments: treduce_func_other_arguments, Tfinalize_func_other_arguments: tfinalize_func_other_arguments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_group_by_window_dataset(input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, key_func: nil, reduce_func: nil, window_size_func: nil, tkey_func_other_arguments: nil, treduce_func_other_arguments: nil, twindow_size_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalGroupByWindowDataset") ⇒ Object 



1310
1311
1312
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1310

def self.experimental_group_by_window_dataset(input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, key_func: nil, reduce_func: nil, window_size_func: nil, tkey_func_other_arguments: nil, treduce_func_other_arguments: nil, twindow_size_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalGroupByWindowDataset")
  self.execute("ExperimentalGroupByWindowDataset", [input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments], key_func: key_func, reduce_func: reduce_func, window_size_func: window_size_func, Tkey_func_other_arguments: tkey_func_other_arguments, Treduce_func_other_arguments: treduce_func_other_arguments, Twindow_size_func_other_arguments: twindow_size_func_other_arguments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_ignore_errors_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalIgnoreErrorsDataset") ⇒ Object 



1314
1315
1316
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1314

def self.experimental_ignore_errors_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalIgnoreErrorsDataset")
  self.execute("ExperimentalIgnoreErrorsDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_iterator_get_device(resource, name: "ExperimentalIteratorGetDevice") ⇒ Object 



1318
1319
1320
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1318

def self.experimental_iterator_get_device(resource, name: "ExperimentalIteratorGetDevice")
  self.execute("ExperimentalIteratorGetDevice", [resource], name: name)
end

.experimental_latency_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "ExperimentalLatencyStatsDataset") ⇒ Object 



1326
1327
1328
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1326

def self.experimental_latency_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "ExperimentalLatencyStatsDataset")
  self.execute("ExperimentalLatencyStatsDataset", [input_dataset, tag], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_lmdb_dataset(filenames, output_types: nil, output_shapes: nil, name: "ExperimentalLMDBDataset") ⇒ Object 



1322
1323
1324
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1322

def self.experimental_lmdb_dataset(filenames, output_types: nil, output_shapes: nil, name: "ExperimentalLMDBDataset")
  self.execute("ExperimentalLMDBDataset", [filenames], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_map_and_batch_dataset(input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, f: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, name: "ExperimentalMapAndBatchDataset") ⇒ Object 



1330
1331
1332
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1330

def self.experimental_map_and_batch_dataset(input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, f: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, name: "ExperimentalMapAndBatchDataset")
  self.execute("ExperimentalMapAndBatchDataset", [input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, preserve_cardinality: preserve_cardinality, name: name)
end

.experimental_map_dataset(input_dataset, other_arguments, f: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, preserve_cardinality: false, name: "ExperimentalMapDataset") ⇒ Object 



1334
1335
1336
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1334

def self.experimental_map_dataset(input_dataset, other_arguments, f: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, preserve_cardinality: false, name: "ExperimentalMapDataset")
  self.execute("ExperimentalMapDataset", [input_dataset, other_arguments], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, use_inter_op_parallelism: use_inter_op_parallelism, preserve_cardinality: preserve_cardinality, name: name)
end

.experimental_matching_files_dataset(patterns, name: "ExperimentalMatchingFilesDataset") ⇒ Object 



1338
1339
1340
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1338

def self.experimental_matching_files_dataset(patterns, name: "ExperimentalMatchingFilesDataset")
  self.execute("ExperimentalMatchingFilesDataset", [patterns], name: name)
end

.experimental_max_intra_op_parallelism_dataset(input_dataset, max_intra_op_parallelism, output_types: nil, output_shapes: nil, name: "ExperimentalMaxIntraOpParallelismDataset") ⇒ Object 



1342
1343
1344
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1342

def self.experimental_max_intra_op_parallelism_dataset(input_dataset, max_intra_op_parallelism, output_types: nil, output_shapes: nil, name: "ExperimentalMaxIntraOpParallelismDataset")
  self.execute("ExperimentalMaxIntraOpParallelismDataset", [input_dataset, max_intra_op_parallelism], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_non_serializable_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalNonSerializableDataset") ⇒ Object 



1346
1347
1348
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1346

def self.experimental_non_serializable_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalNonSerializableDataset")
  self.execute("ExperimentalNonSerializableDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_parallel_interleave_dataset(input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalParallelInterleaveDataset") ⇒ Object 



1350
1351
1352
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1350

def self.experimental_parallel_interleave_dataset(input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalParallelInterleaveDataset")
  self.execute("ExperimentalParallelInterleaveDataset", [input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_parse_example_dataset(input_dataset, num_parallel_calls, dense_defaults, sparse_keys: nil, dense_keys: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, output_types: nil, output_shapes: nil, sloppy: false, name: "ExperimentalParseExampleDataset") ⇒ Object 



1354
1355
1356
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1354

def self.experimental_parse_example_dataset(input_dataset, num_parallel_calls, dense_defaults, sparse_keys: nil, dense_keys: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, output_types: nil, output_shapes: nil, sloppy: false, name: "ExperimentalParseExampleDataset")
  self.execute("ExperimentalParseExampleDataset", [input_dataset, num_parallel_calls, dense_defaults], sparse_keys: sparse_keys, dense_keys: dense_keys, sparse_types: sparse_types, Tdense: tdense, dense_shapes: dense_shapes, output_types: output_types, output_shapes: output_shapes, sloppy: sloppy, name: name)
end

.experimental_private_thread_pool_dataset(input_dataset, num_threads, output_types: nil, output_shapes: nil, name: "ExperimentalPrivateThreadPoolDataset") ⇒ Object 



1358
1359
1360
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1358

def self.experimental_private_thread_pool_dataset(input_dataset, num_threads, output_types: nil, output_shapes: nil, name: "ExperimentalPrivateThreadPoolDataset")
  self.execute("ExperimentalPrivateThreadPoolDataset", [input_dataset, num_threads], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_random_dataset(seed, seed2, output_types: nil, output_shapes: nil, name: "ExperimentalRandomDataset") ⇒ Object 



1362
1363
1364
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1362

def self.experimental_random_dataset(seed, seed2, output_types: nil, output_shapes: nil, name: "ExperimentalRandomDataset")
  self.execute("ExperimentalRandomDataset", [seed, seed2], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_rebatch_dataset(input_dataset, num_replicas, output_types: nil, output_shapes: nil, use_fallback: true, name: "ExperimentalRebatchDataset") ⇒ Object 



1366
1367
1368
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1366

def self.experimental_rebatch_dataset(input_dataset, num_replicas, output_types: nil, output_shapes: nil, use_fallback: true, name: "ExperimentalRebatchDataset")
  self.execute("ExperimentalRebatchDataset", [input_dataset, num_replicas], output_types: output_types, output_shapes: output_shapes, use_fallback: use_fallback, name: name)
end

.experimental_scan_dataset(input_dataset, initial_state, other_arguments, f: nil, tstate: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, name: "ExperimentalScanDataset") ⇒ Object 



1370
1371
1372
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1370

def self.experimental_scan_dataset(input_dataset, initial_state, other_arguments, f: nil, tstate: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, name: "ExperimentalScanDataset")
  self.execute("ExperimentalScanDataset", [input_dataset, initial_state, other_arguments], f: f, Tstate: tstate, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, preserve_cardinality: preserve_cardinality, name: name)
end

.experimental_set_stats_aggregator_dataset(input_dataset, stats_aggregator, tag, counter_prefix, output_types: nil, output_shapes: nil, name: "ExperimentalSetStatsAggregatorDataset") ⇒ Object 



1374
1375
1376
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1374

def self.experimental_set_stats_aggregator_dataset(input_dataset, stats_aggregator, tag, counter_prefix, output_types: nil, output_shapes: nil, name: "ExperimentalSetStatsAggregatorDataset")
  self.execute("ExperimentalSetStatsAggregatorDataset", [input_dataset, stats_aggregator, tag, counter_prefix], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_sleep_dataset(input_dataset, sleep_microseconds, output_types: nil, output_shapes: nil, name: "ExperimentalSleepDataset") ⇒ Object 



1378
1379
1380
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1378

def self.experimental_sleep_dataset(input_dataset, sleep_microseconds, output_types: nil, output_shapes: nil, name: "ExperimentalSleepDataset")
  self.execute("ExperimentalSleepDataset", [input_dataset, sleep_microseconds], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_sliding_window_dataset(input_dataset, window_size, window_shift, window_stride, output_types: nil, output_shapes: nil, name: "ExperimentalSlidingWindowDataset") ⇒ Object 



1382
1383
1384
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1382

def self.experimental_sliding_window_dataset(input_dataset, window_size, window_shift, window_stride, output_types: nil, output_shapes: nil, name: "ExperimentalSlidingWindowDataset")
  self.execute("ExperimentalSlidingWindowDataset", [input_dataset, window_size, window_shift, window_stride], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_sql_dataset(driver_name, data_source_name, query, output_types: nil, output_shapes: nil, name: "ExperimentalSqlDataset") ⇒ Object 



1386
1387
1388
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1386

def self.experimental_sql_dataset(driver_name, data_source_name, query, output_types: nil, output_shapes: nil, name: "ExperimentalSqlDataset")
  self.execute("ExperimentalSqlDataset", [driver_name, data_source_name, query], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_stats_aggregator_handle(container: "", shared_name: "", name: "ExperimentalStatsAggregatorHandle") ⇒ Object 



1390
1391
1392
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1390

def self.experimental_stats_aggregator_handle(container: "", shared_name: "", name: "ExperimentalStatsAggregatorHandle")
  self.execute("ExperimentalStatsAggregatorHandle", [], container: container, shared_name: shared_name, name: name)
end

.experimental_stats_aggregator_summary(iterator, name: "ExperimentalStatsAggregatorSummary") ⇒ Object 



1394
1395
1396
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1394

def self.experimental_stats_aggregator_summary(iterator, name: "ExperimentalStatsAggregatorSummary")
  self.execute("ExperimentalStatsAggregatorSummary", [iterator], name: name)
end

.experimental_take_while_dataset(input_dataset, other_arguments, predicate: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalTakeWhileDataset") ⇒ Object 



1398
1399
1400
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1398

def self.experimental_take_while_dataset(input_dataset, other_arguments, predicate: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "ExperimentalTakeWhileDataset")
  self.execute("ExperimentalTakeWhileDataset", [input_dataset, other_arguments], predicate: predicate, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_thread_pool_dataset(input_dataset, thread_pool, output_types: nil, output_shapes: nil, name: "ExperimentalThreadPoolDataset") ⇒ Object 



1402
1403
1404
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1402

def self.experimental_thread_pool_dataset(input_dataset, thread_pool, output_types: nil, output_shapes: nil, name: "ExperimentalThreadPoolDataset")
  self.execute("ExperimentalThreadPoolDataset", [input_dataset, thread_pool], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_thread_pool_handle(num_threads: nil, max_intra_op_parallelism: 1, display_name: "", container: "", shared_name: "", name: "ExperimentalThreadPoolHandle") ⇒ Object 



1406
1407
1408
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1406

def self.experimental_thread_pool_handle(num_threads: nil, max_intra_op_parallelism: 1, display_name: "", container: "", shared_name: "", name: "ExperimentalThreadPoolHandle")
  self.execute("ExperimentalThreadPoolHandle", [], num_threads: num_threads, max_intra_op_parallelism: max_intra_op_parallelism, display_name: display_name, container: container, shared_name: shared_name, name: name)
end

.experimental_unbatch_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalUnbatchDataset") ⇒ Object 



1410
1411
1412
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1410

def self.experimental_unbatch_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalUnbatchDataset")
  self.execute("ExperimentalUnbatchDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.experimental_unique_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalUniqueDataset") ⇒ Object 



1414
1415
1416
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1414

def self.experimental_unique_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "ExperimentalUniqueDataset")
  self.execute("ExperimentalUniqueDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.expm1(x, typeT: nil, name: "Expm1") ⇒ Object 



1418
1419
1420
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1418

def self.expm1(x, typeT: nil, name: "Expm1")
  self.execute("Expm1", [x], T: typeT, name: name)
end

.extract_glimpse(input, size, offsets, centered: true, normalized: true, uniform_noise: true, noise: "uniform", name: "ExtractGlimpse") ⇒ Object 



1422
1423
1424
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1422

def self.extract_glimpse(input, size, offsets, centered: true, normalized: true, uniform_noise: true, noise: "uniform", name: "ExtractGlimpse")
  self.execute("ExtractGlimpse", [input, size, offsets], centered: centered, normalized: normalized, uniform_noise: uniform_noise, noise: noise, name: name)
end

.extract_image_patches(images, ksizes: nil, strides: nil, rates: nil, typeT: nil, padding: nil, name: "ExtractImagePatches") ⇒ Object 



1426
1427
1428
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1426

def self.extract_image_patches(images, ksizes: nil, strides: nil, rates: nil, typeT: nil, padding: nil, name: "ExtractImagePatches")
  self.execute("ExtractImagePatches", [images], ksizes: ksizes, strides: strides, rates: rates, T: typeT, padding: padding, name: name)
end

.extract_jpeg_shape(contents, output_type: :int32, name: "ExtractJpegShape") ⇒ Object 



1430
1431
1432
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1430

def self.extract_jpeg_shape(contents, output_type: :int32, name: "ExtractJpegShape")
  self.execute("ExtractJpegShape", [contents], output_type: output_type, name: name)
end

.extract_volume_patches(input, ksizes: nil, strides: nil, typeT: nil, padding: nil, name: "ExtractVolumePatches") ⇒ Object 



1434
1435
1436
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1434

def self.extract_volume_patches(input, ksizes: nil, strides: nil, typeT: nil, padding: nil, name: "ExtractVolumePatches")
  self.execute("ExtractVolumePatches", [input], ksizes: ksizes, strides: strides, T: typeT, padding: padding, name: name)
end

.fact(name: "Fact") ⇒ Object 



1458
1459
1460
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1458

def self.fact(name: "Fact")
  self.execute("Fact", [], name: name)
end

.fake_param(dtype: nil, shape: nil, name: "FakeParam") ⇒ Object 



1462
1463
1464
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1462

def self.fake_param(dtype: nil, shape: nil, name: "FakeParam")
  self.execute("FakeParam", [], dtype: dtype, shape: shape, name: name)
end

.fake_quant_with_min_max_args(inputs, min: -6.0,, max: 6.0, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxArgs") ⇒ Object 



1466
1467
1468
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1466

def self.fake_quant_with_min_max_args(inputs, min: -6.0, max: 6.0, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxArgs")
  self.execute("FakeQuantWithMinMaxArgs", [inputs], min: min, max: max, num_bits: num_bits, narrow_range: narrow_range, name: name)
end

.fake_quant_with_min_max_args_gradient(gradients, inputs, min: -6.0,, max: 6.0, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxArgsGradient") ⇒ Object 



1470
1471
1472
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1470

def self.fake_quant_with_min_max_args_gradient(gradients, inputs, min: -6.0, max: 6.0, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxArgsGradient")
  self.execute("FakeQuantWithMinMaxArgsGradient", [gradients, inputs], min: min, max: max, num_bits: num_bits, narrow_range: narrow_range, name: name)
end

.fake_quant_with_min_max_vars(inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVars") ⇒ Object 



1474
1475
1476
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1474

def self.fake_quant_with_min_max_vars(inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVars")
  self.execute("FakeQuantWithMinMaxVars", [inputs, min, max], num_bits: num_bits, narrow_range: narrow_range, name: name)
end

.fake_quant_with_min_max_vars_gradient(gradients, inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVarsGradient") ⇒ Object 



1478
1479
1480
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1478

def self.fake_quant_with_min_max_vars_gradient(gradients, inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVarsGradient")
  self.execute("FakeQuantWithMinMaxVarsGradient", [gradients, inputs, min, max], num_bits: num_bits, narrow_range: narrow_range, name: name)
end

.fake_quant_with_min_max_vars_per_channel(inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVarsPerChannel") ⇒ Object 



1482
1483
1484
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1482

def self.fake_quant_with_min_max_vars_per_channel(inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVarsPerChannel")
  self.execute("FakeQuantWithMinMaxVarsPerChannel", [inputs, min, max], num_bits: num_bits, narrow_range: narrow_range, name: name)
end

.fake_quant_with_min_max_vars_per_channel_gradient(gradients, inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVarsPerChannelGradient") ⇒ Object 



1486
1487
1488
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1486

def self.fake_quant_with_min_max_vars_per_channel_gradient(gradients, inputs, min, max, num_bits: 8, narrow_range: false, name: "FakeQuantWithMinMaxVarsPerChannelGradient")
  self.execute("FakeQuantWithMinMaxVarsPerChannelGradient", [gradients, inputs, min, max], num_bits: num_bits, narrow_range: narrow_range, name: name)
end

.fake_queue(resource, name: "FakeQueue") ⇒ Object 



1490
1491
1492
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1490

def self.fake_queue(resource, name: "FakeQueue")
  self.execute("FakeQueue", [resource], name: name)
end

.fft(input, tcomplex: :complex64, name: "FFT") ⇒ Object 



1438
1439
1440
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1438

def self.fft(input, tcomplex: :complex64, name: "FFT")
  self.execute("FFT", [input], Tcomplex: tcomplex, name: name)
end

.fft2_d(input, tcomplex: :complex64, name: "FFT2D") ⇒ Object 



1442
1443
1444
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1442

def self.fft2_d(input, tcomplex: :complex64, name: "FFT2D")
  self.execute("FFT2D", [input], Tcomplex: tcomplex, name: name)
end

.fft3_d(input, tcomplex: :complex64, name: "FFT3D") ⇒ Object 



1446
1447
1448
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1446

def self.fft3_d(input, tcomplex: :complex64, name: "FFT3D")
  self.execute("FFT3D", [input], Tcomplex: tcomplex, name: name)
end

.fifo_queue(component_types: nil, shapes: [], capacity: -1,, container: "", shared_name: "", name: "FIFOQueue") ⇒ Object 



1450
1451
1452
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1450

def self.fifo_queue(component_types: nil, shapes: [], capacity: -1, container: "", shared_name: "", name: "FIFOQueue")
  self.execute("FIFOQueue", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.fifo_queue_v2(component_types: nil, shapes: [], capacity: -1,, container: "", shared_name: "", name: "FIFOQueueV2") ⇒ Object 



1454
1455
1456
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1454

def self.fifo_queue_v2(component_types: nil, shapes: [], capacity: -1, container: "", shared_name: "", name: "FIFOQueueV2")
  self.execute("FIFOQueueV2", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.fill(dims, value, typeT: nil, index_type: :int32, name: "Fill") ⇒ Object 



1494
1495
1496
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1494

def self.fill(dims, value, typeT: nil, index_type: :int32, name: "Fill")
  self.execute("Fill", [dims, value], T: typeT, index_type: index_type, name: name)
end

.filter_by_last_component_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "FilterByLastComponentDataset") ⇒ Object 



1498
1499
1500
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1498

def self.filter_by_last_component_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "FilterByLastComponentDataset")
  self.execute("FilterByLastComponentDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.filter_dataset(input_dataset, other_arguments, predicate: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "FilterDataset") ⇒ Object 



1502
1503
1504
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1502

def self.filter_dataset(input_dataset, other_arguments, predicate: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "FilterDataset")
  self.execute("FilterDataset", [input_dataset, other_arguments], predicate: predicate, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.fingerprint(data, method, typeT: nil, name: "Fingerprint") ⇒ Object 



1506
1507
1508
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1506

def self.fingerprint(data, method, typeT: nil, name: "Fingerprint")
  self.execute("Fingerprint", [data, method], T: typeT, name: name)
end

.fixed_length_record_dataset(filenames, header_bytes, record_bytes, footer_bytes, buffer_size, name: "FixedLengthRecordDataset") ⇒ Object 



1510
1511
1512
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1510

def self.fixed_length_record_dataset(filenames, header_bytes, record_bytes, footer_bytes, buffer_size, name: "FixedLengthRecordDataset")
  self.execute("FixedLengthRecordDataset", [filenames, header_bytes, record_bytes, footer_bytes, buffer_size], name: name)
end

.fixed_length_record_dataset_v2(filenames, header_bytes, record_bytes, footer_bytes, buffer_size, compression_type, name: "FixedLengthRecordDatasetV2") ⇒ Object 



1514
1515
1516
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1514

def self.fixed_length_record_dataset_v2(filenames, header_bytes, record_bytes, footer_bytes, buffer_size, compression_type, name: "FixedLengthRecordDatasetV2")
  self.execute("FixedLengthRecordDatasetV2", [filenames, header_bytes, record_bytes, footer_bytes, buffer_size, compression_type], name: name)
end

.fixed_length_record_reader(header_bytes: 0, record_bytes: nil, footer_bytes: 0, hop_bytes: 0, container: "", shared_name: "", name: "FixedLengthRecordReader") ⇒ Object 



1518
1519
1520
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1518

def self.fixed_length_record_reader(header_bytes: 0, record_bytes: nil, footer_bytes: 0, hop_bytes: 0, container: "", shared_name: "", name: "FixedLengthRecordReader")
  self.execute("FixedLengthRecordReader", [], header_bytes: header_bytes, record_bytes: record_bytes, footer_bytes: footer_bytes, hop_bytes: hop_bytes, container: container, shared_name: shared_name, name: name)
end

.fixed_length_record_reader_v2(header_bytes: 0, record_bytes: nil, footer_bytes: 0, hop_bytes: 0, container: "", shared_name: "", encoding: "", name: "FixedLengthRecordReaderV2") ⇒ Object 



1522
1523
1524
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1522

def self.fixed_length_record_reader_v2(header_bytes: 0, record_bytes: nil, footer_bytes: 0, hop_bytes: 0, container: "", shared_name: "", encoding: "", name: "FixedLengthRecordReaderV2")
  self.execute("FixedLengthRecordReaderV2", [], header_bytes: header_bytes, record_bytes: record_bytes, footer_bytes: footer_bytes, hop_bytes: hop_bytes, container: container, shared_name: shared_name, encoding: encoding, name: name)
end

.fixed_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, vocab_file: "", distortion: 1.0, num_reserved_ids: 0, num_shards: 1, shard: 0, unigrams: [], seed: 0, seed2: 0, name: "FixedUnigramCandidateSampler") ⇒ Object 



1526
1527
1528
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1526

def self.fixed_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, vocab_file: "", distortion: 1.0, num_reserved_ids: 0, num_shards: 1, shard: 0, unigrams: [], seed: 0, seed2: 0, name: "FixedUnigramCandidateSampler")
  self.execute("FixedUnigramCandidateSampler", [true_classes], num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, vocab_file: vocab_file, distortion: distortion, num_reserved_ids: num_reserved_ids, num_shards: num_shards, shard: shard, unigrams: unigrams, seed: seed, seed2: seed2, name: name)
end

.flat_map_dataset(input_dataset, other_arguments, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "FlatMapDataset") ⇒ Object 



1530
1531
1532
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1530

def self.flat_map_dataset(input_dataset, other_arguments, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "FlatMapDataset")
  self.execute("FlatMapDataset", [input_dataset, other_arguments], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.floor(x, typeT: nil, name: "Floor") ⇒ Object 



1534
1535
1536
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1534

def self.floor(x, typeT: nil, name: "Floor")
  self.execute("Floor", [x], T: typeT, name: name)
end

.floor_div(x, y, typeT: nil, name: "FloorDiv") ⇒ Object 



1538
1539
1540
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1538

def self.floor_div(x, y, typeT: nil, name: "FloorDiv")
  self.execute("FloorDiv", [x, y], T: typeT, name: name)
end

.floor_mod(x, y, typeT: nil, name: "FloorMod") ⇒ Object 



1542
1543
1544
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1542

def self.floor_mod(x, y, typeT: nil, name: "FloorMod")
  self.execute("FloorMod", [x, y], T: typeT, name: name)
end

.flush_summary_writer(writer, name: "FlushSummaryWriter") ⇒ Object 



1546
1547
1548
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1546

def self.flush_summary_writer(writer, name: "FlushSummaryWriter")
  self.execute("FlushSummaryWriter", [writer], name: name)
end

.for(start, limit, delta, input, typeT: nil, body: nil, name: "For") ⇒ Object 



1550
1551
1552
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1550

def self.for(start, limit, delta, input, typeT: nil, body: nil, name: "For")
  self.execute("For", [start, limit, delta, input], T: typeT, body: body, name: name)
end

.fractional_avg_pool(value, pooling_ratio: nil, pseudo_random: false, overlapping: false, deterministic: false, seed: 0, seed2: 0, typeT: nil, name: "FractionalAvgPool") ⇒ Object 



1554
1555
1556
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1554

def self.fractional_avg_pool(value, pooling_ratio: nil, pseudo_random: false, overlapping: false, deterministic: false, seed: 0, seed2: 0, typeT: nil, name: "FractionalAvgPool")
  self.execute("FractionalAvgPool", [value], pooling_ratio: pooling_ratio, pseudo_random: pseudo_random, overlapping: overlapping, deterministic: deterministic, seed: seed, seed2: seed2, T: typeT, name: name)
end

.fractional_avg_pool_grad(orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping: false, typeT: nil, name: "FractionalAvgPoolGrad") ⇒ Object 



1558
1559
1560
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1558

def self.fractional_avg_pool_grad(orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping: false, typeT: nil, name: "FractionalAvgPoolGrad")
  self.execute("FractionalAvgPoolGrad", [orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence], overlapping: overlapping, T: typeT, name: name)
end

.fractional_max_pool(value, pooling_ratio: nil, pseudo_random: false, overlapping: false, deterministic: false, seed: 0, seed2: 0, typeT: nil, name: "FractionalMaxPool") ⇒ Object 



1562
1563
1564
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1562

def self.fractional_max_pool(value, pooling_ratio: nil, pseudo_random: false, overlapping: false, deterministic: false, seed: 0, seed2: 0, typeT: nil, name: "FractionalMaxPool")
  self.execute("FractionalMaxPool", [value], pooling_ratio: pooling_ratio, pseudo_random: pseudo_random, overlapping: overlapping, deterministic: deterministic, seed: seed, seed2: seed2, T: typeT, name: name)
end

.fractional_max_pool_grad(orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping: false, typeT: nil, name: "FractionalMaxPoolGrad") ⇒ Object 



1566
1567
1568
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1566

def self.fractional_max_pool_grad(orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping: false, typeT: nil, name: "FractionalMaxPoolGrad")
  self.execute("FractionalMaxPoolGrad", [orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence], overlapping: overlapping, T: typeT, name: name)
end

.fused_batch_norm(x, scale, offset, mean, variance, typeT: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNorm") ⇒ Object 



1570
1571
1572
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1570

def self.fused_batch_norm(x, scale, offset, mean, variance, typeT: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNorm")
  self.execute("FusedBatchNorm", [x, scale, offset, mean, variance], T: typeT, epsilon: epsilon, data_format: data_format, is_training: is_training, name: name)
end

.fused_batch_norm_grad(y_backprop, x, scale, reserve_space_1, reserve_space_2, typeT: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormGrad") ⇒ Object 



1574
1575
1576
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1574

def self.fused_batch_norm_grad(y_backprop, x, scale, reserve_space_1, reserve_space_2, typeT: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormGrad")
  self.execute("FusedBatchNormGrad", [y_backprop, x, scale, reserve_space_1, reserve_space_2], T: typeT, epsilon: epsilon, data_format: data_format, is_training: is_training, name: name)
end

.fused_batch_norm_grad_v2(y_backprop, x, scale, reserve_space_1, reserve_space_2, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormGradV2") ⇒ Object 



1578
1579
1580
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1578

def self.fused_batch_norm_grad_v2(y_backprop, x, scale, reserve_space_1, reserve_space_2, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormGradV2")
  self.execute("FusedBatchNormGradV2", [y_backprop, x, scale, reserve_space_1, reserve_space_2], T: typeT, U: u, epsilon: epsilon, data_format: data_format, is_training: is_training, name: name)
end

.fused_batch_norm_grad_v3(y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormGradV3") ⇒ Object 



1582
1583
1584
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1582

def self.fused_batch_norm_grad_v3(y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormGradV3")
  self.execute("FusedBatchNormGradV3", [y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3], T: typeT, U: u, epsilon: epsilon, data_format: data_format, is_training: is_training, name: name)
end

.fused_batch_norm_v2(x, scale, offset, mean, variance, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormV2") ⇒ Object 



1586
1587
1588
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1586

def self.fused_batch_norm_v2(x, scale, offset, mean, variance, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormV2")
  self.execute("FusedBatchNormV2", [x, scale, offset, mean, variance], T: typeT, U: u, epsilon: epsilon, data_format: data_format, is_training: is_training, name: name)
end

.fused_batch_norm_v3(x, scale, offset, mean, variance, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormV3") ⇒ Object 



1590
1591
1592
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1590

def self.fused_batch_norm_v3(x, scale, offset, mean, variance, typeT: nil, u: nil, epsilon: 9.999999747378752e-05, data_format: "NHWC", is_training: true, name: "FusedBatchNormV3")
  self.execute("FusedBatchNormV3", [x, scale, offset, mean, variance], T: typeT, U: u, epsilon: epsilon, data_format: data_format, is_training: is_training, name: name)
end

.fused_pad_conv2_d(input, paddings, filter, typeT: nil, mode: nil, strides: nil, padding: nil, name: "FusedPadConv2D") ⇒ Object 



1594
1595
1596
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1594

def self.fused_pad_conv2_d(input, paddings, filter, typeT: nil, mode: nil, strides: nil, padding: nil, name: "FusedPadConv2D")
  self.execute("FusedPadConv2D", [input, paddings, filter], T: typeT, mode: mode, strides: strides, padding: padding, name: name)
end

.fused_resize_and_pad_conv2_d(input, size, paddings, filter, typeT: nil, resize_align_corners: false, mode: nil, strides: nil, padding: nil, name: "FusedResizeAndPadConv2D") ⇒ Object 



1598
1599
1600
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1598

def self.fused_resize_and_pad_conv2_d(input, size, paddings, filter, typeT: nil, resize_align_corners: false, mode: nil, strides: nil, padding: nil, name: "FusedResizeAndPadConv2D")
  self.execute("FusedResizeAndPadConv2D", [input, size, paddings, filter], T: typeT, resize_align_corners: resize_align_corners, mode: mode, strides: strides, padding: padding, name: name)
end

.gather(params, indices, validate_indices: true, tparams: nil, tindices: nil, name: "Gather") ⇒ Object 



1610
1611
1612
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1610

def self.gather(params, indices, validate_indices: true, tparams: nil, tindices: nil, name: "Gather")
  self.execute("Gather", [params, indices], validate_indices: validate_indices, Tparams: tparams, Tindices: tindices, name: name)
end

.gather_nd(params, indices, tparams: nil, tindices: nil, name: "GatherNd") ⇒ Object 



1614
1615
1616
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1614

def self.gather_nd(params, indices, tparams: nil, tindices: nil, name: "GatherNd")
  self.execute("GatherNd", [params, indices], Tparams: tparams, Tindices: tindices, name: name)
end

.gather_v2(params, indices, axis, batch_dims: 0, tparams: nil, tindices: nil, taxis: nil, name: "GatherV2") ⇒ Object 



1618
1619
1620
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1618

def self.gather_v2(params, indices, axis, batch_dims: 0, tparams: nil, tindices: nil, taxis: nil, name: "GatherV2")
  self.execute("GatherV2", [params, indices, axis], batch_dims: batch_dims, Tparams: tparams, Tindices: tindices, Taxis: taxis, name: name)
end

.generate_vocab_remapping(new_vocab_file, old_vocab_file, new_vocab_offset: nil, num_new_vocab: nil, old_vocab_size: -1,, name: "GenerateVocabRemapping") ⇒ Object 



1622
1623
1624
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1622

def self.generate_vocab_remapping(new_vocab_file, old_vocab_file, new_vocab_offset: nil, num_new_vocab: nil, old_vocab_size: -1, name: "GenerateVocabRemapping")
  self.execute("GenerateVocabRemapping", [new_vocab_file, old_vocab_file], new_vocab_offset: new_vocab_offset, num_new_vocab: num_new_vocab, old_vocab_size: old_vocab_size, name: name)
end

.generator_dataset(init_func_other_args, next_func_other_args, finalize_func_other_args, init_func: nil, next_func: nil, finalize_func: nil, tinit_func_args: nil, tnext_func_args: nil, tfinalize_func_args: nil, output_types: nil, output_shapes: nil, name: "GeneratorDataset") ⇒ Object 



1626
1627
1628
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1626

def self.generator_dataset(init_func_other_args, next_func_other_args, finalize_func_other_args, init_func: nil, next_func: nil, finalize_func: nil, tinit_func_args: nil, tnext_func_args: nil, tfinalize_func_args: nil, output_types: nil, output_shapes: nil, name: "GeneratorDataset")
  self.execute("GeneratorDataset", [init_func_other_args, next_func_other_args, finalize_func_other_args], init_func: init_func, next_func: next_func, finalize_func: finalize_func, Tinit_func_args: tinit_func_args, Tnext_func_args: tnext_func_args, Tfinalize_func_args: tfinalize_func_args, output_types: output_types, output_shapes: output_shapes, name: name)
end

.get_session_handle(value, typeT: nil, name: "GetSessionHandle") ⇒ Object 



1630
1631
1632
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1630

def self.get_session_handle(value, typeT: nil, name: "GetSessionHandle")
  self.execute("GetSessionHandle", [value], T: typeT, name: name)
end

.get_session_handle_v2(value, typeT: nil, name: "GetSessionHandleV2") ⇒ Object 



1634
1635
1636
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1634

def self.get_session_handle_v2(value, typeT: nil, name: "GetSessionHandleV2")
  self.execute("GetSessionHandleV2", [value], T: typeT, name: name)
end

.get_session_tensor(handle, dtype: nil, name: "GetSessionTensor") ⇒ Object 



1638
1639
1640
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1638

def self.get_session_tensor(handle, dtype: nil, name: "GetSessionTensor")
  self.execute("GetSessionTensor", [handle], dtype: dtype, name: name)
end

.greater(x, y, typeT: nil, name: "Greater") ⇒ Object 



1642
1643
1644
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1642

def self.greater(x, y, typeT: nil, name: "Greater")
  self.execute("Greater", [x, y], T: typeT, name: name)
end

.greater_equal(x, y, typeT: nil, name: "GreaterEqual") ⇒ Object 



1646
1647
1648
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1646

def self.greater_equal(x, y, typeT: nil, name: "GreaterEqual")
  self.execute("GreaterEqual", [x, y], T: typeT, name: name)
end

.group_by_reducer_dataset(input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments, key_func: nil, init_func: nil, reduce_func: nil, finalize_func: nil, tkey_func_other_arguments: nil, tinit_func_other_arguments: nil, treduce_func_other_arguments: nil, tfinalize_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "GroupByReducerDataset") ⇒ Object 



1650
1651
1652
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1650

def self.group_by_reducer_dataset(input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments, key_func: nil, init_func: nil, reduce_func: nil, finalize_func: nil, tkey_func_other_arguments: nil, tinit_func_other_arguments: nil, treduce_func_other_arguments: nil, tfinalize_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "GroupByReducerDataset")
  self.execute("GroupByReducerDataset", [input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments], key_func: key_func, init_func: init_func, reduce_func: reduce_func, finalize_func: finalize_func, Tkey_func_other_arguments: tkey_func_other_arguments, Tinit_func_other_arguments: tinit_func_other_arguments, Treduce_func_other_arguments: treduce_func_other_arguments, Tfinalize_func_other_arguments: tfinalize_func_other_arguments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.group_by_window_dataset(input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, key_func: nil, reduce_func: nil, window_size_func: nil, tkey_func_other_arguments: nil, treduce_func_other_arguments: nil, twindow_size_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "GroupByWindowDataset") ⇒ Object 



1654
1655
1656
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1654

def self.group_by_window_dataset(input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, key_func: nil, reduce_func: nil, window_size_func: nil, tkey_func_other_arguments: nil, treduce_func_other_arguments: nil, twindow_size_func_other_arguments: nil, output_types: nil, output_shapes: nil, name: "GroupByWindowDataset")
  self.execute("GroupByWindowDataset", [input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments], key_func: key_func, reduce_func: reduce_func, window_size_func: window_size_func, Tkey_func_other_arguments: tkey_func_other_arguments, Treduce_func_other_arguments: treduce_func_other_arguments, Twindow_size_func_other_arguments: twindow_size_func_other_arguments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.gru_block_cell(x, h_prev, w_ru, w_c, b_ru, b_c, typeT: nil, name: "GRUBlockCell") ⇒ Object 



1602
1603
1604
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1602

def self.gru_block_cell(x, h_prev, w_ru, w_c, b_ru, b_c, typeT: nil, name: "GRUBlockCell")
  self.execute("GRUBlockCell", [x, h_prev, w_ru, w_c, b_ru, b_c], T: typeT, name: name)
end

.gru_block_cell_grad(x, h_prev, w_ru, w_c, b_ru, b_c, r, u, c, d_h, typeT: nil, name: "GRUBlockCellGrad") ⇒ Object 



1606
1607
1608
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1606

def self.gru_block_cell_grad(x, h_prev, w_ru, w_c, b_ru, b_c, r, u, c, d_h, typeT: nil, name: "GRUBlockCellGrad")
  self.execute("GRUBlockCellGrad", [x, h_prev, w_ru, w_c, b_ru, b_c, r, u, c, d_h], T: typeT, name: name)
end

.guarantee_const(input, typeT: nil, name: "GuaranteeConst") ⇒ Object 



1658
1659
1660
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1658

def self.guarantee_const(input, typeT: nil, name: "GuaranteeConst")
  self.execute("GuaranteeConst", [input], T: typeT, name: name)
end

.hash_table(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "HashTable") ⇒ Object 



1666
1667
1668
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1666

def self.hash_table(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "HashTable")
  self.execute("HashTable", [], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, name: name)
end

.hash_table_v2(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "HashTableV2") ⇒ Object 



1670
1671
1672
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1670

def self.hash_table_v2(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "HashTableV2")
  self.execute("HashTableV2", [], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, name: name)
end

.histogram_fixed_width(values, value_range, nbins, typeT: nil, dtype: :int32, name: "HistogramFixedWidth") ⇒ Object 



1674
1675
1676
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1674

def self.histogram_fixed_width(values, value_range, nbins, typeT: nil, dtype: :int32, name: "HistogramFixedWidth")
  self.execute("HistogramFixedWidth", [values, value_range, nbins], T: typeT, dtype: dtype, name: name)
end

.histogram_summary(tag, values, typeT: :float, name: "HistogramSummary") ⇒ Object 



1678
1679
1680
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1678

def self.histogram_summary(tag, values, typeT: :float, name: "HistogramSummary")
  self.execute("HistogramSummary", [tag, values], T: typeT, name: name)
end

.host_const(value: nil, dtype: nil, name: "HostConst") ⇒ Object 



1682
1683
1684
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1682

def self.host_const(value: nil, dtype: nil, name: "HostConst")
  self.execute("HostConst", [], value: value, dtype: dtype, name: name)
end

.hsv_to_rgb(images, typeT: :float, name: "HSVToRGB") ⇒ Object 



1662
1663
1664
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1662

def self.hsv_to_rgb(images, typeT: :float, name: "HSVToRGB")
  self.execute("HSVToRGB", [images], T: typeT, name: name)
end

.identity(input, typeT: nil, name: "Identity") ⇒ Object 



1710
1711
1712
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1710

def self.identity(input, typeT: nil, name: "Identity")
  self.execute("Identity", [input], T: typeT, name: name)
end

.identity_n(input, typeT: nil, name: "IdentityN") ⇒ Object 



1714
1715
1716
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1714

def self.identity_n(input, typeT: nil, name: "IdentityN")
  self.execute("IdentityN", [input], T: typeT, name: name)
end

.identity_reader(container: "", shared_name: "", name: "IdentityReader") ⇒ Object 



1718
1719
1720
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1718

def self.identity_reader(container: "", shared_name: "", name: "IdentityReader")
  self.execute("IdentityReader", [], container: container, shared_name: shared_name, name: name)
end

.identity_reader_v2(container: "", shared_name: "", name: "IdentityReaderV2") ⇒ Object 



1722
1723
1724
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1722

def self.identity_reader_v2(container: "", shared_name: "", name: "IdentityReaderV2")
  self.execute("IdentityReaderV2", [], container: container, shared_name: shared_name, name: name)
end

.if(cond, input, tcond: nil, tin: nil, tout: nil, then_branch: nil, else_branch: nil, output_shapes: [], name: "If") ⇒ Object 



1726
1727
1728
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1726

def self.if(cond, input, tcond: nil, tin: nil, tout: nil, then_branch: nil, else_branch: nil, output_shapes: [], name: "If")
  self.execute("If", [cond, input], Tcond: tcond, Tin: tin, Tout: tout, then_branch: then_branch, else_branch: else_branch, output_shapes: output_shapes, name: name)
end

.ifft(input, tcomplex: :complex64, name: "IFFT") ⇒ Object 



1686
1687
1688
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1686

def self.ifft(input, tcomplex: :complex64, name: "IFFT")
  self.execute("IFFT", [input], Tcomplex: tcomplex, name: name)
end

.ifft2_d(input, tcomplex: :complex64, name: "IFFT2D") ⇒ Object 



1690
1691
1692
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1690

def self.ifft2_d(input, tcomplex: :complex64, name: "IFFT2D")
  self.execute("IFFT2D", [input], Tcomplex: tcomplex, name: name)
end

.ifft3_d(input, tcomplex: :complex64, name: "IFFT3D") ⇒ Object 



1694
1695
1696
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1694

def self.ifft3_d(input, tcomplex: :complex64, name: "IFFT3D")
  self.execute("IFFT3D", [input], Tcomplex: tcomplex, name: name)
end

.igamma(a, x, typeT: nil, name: "Igamma") ⇒ Object 



1730
1731
1732
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1730

def self.igamma(a, x, typeT: nil, name: "Igamma")
  self.execute("Igamma", [a, x], T: typeT, name: name)
end

.igamma_grad_a(a, x, typeT: nil, name: "IgammaGradA") ⇒ Object 



1734
1735
1736
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1734

def self.igamma_grad_a(a, x, typeT: nil, name: "IgammaGradA")
  self.execute("IgammaGradA", [a, x], T: typeT, name: name)
end

.igammac(a, x, typeT: nil, name: "Igammac") ⇒ Object 



1738
1739
1740
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1738

def self.igammac(a, x, typeT: nil, name: "Igammac")
  self.execute("Igammac", [a, x], T: typeT, name: name)
end

.ignore_errors_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "IgnoreErrorsDataset") ⇒ Object 



1742
1743
1744
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1742

def self.ignore_errors_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "IgnoreErrorsDataset")
  self.execute("IgnoreErrorsDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.imag(input, typeT: :complex64, tout: :float, name: "Imag") ⇒ Object 



1746
1747
1748
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1746

def self.imag(input, typeT: :complex64, tout: :float, name: "Imag")
  self.execute("Imag", [input], T: typeT, Tout: tout, name: name)
end

.image_summary(tag, tensor, max_images: 3, typeT: :float, bad_color: [], name: "ImageSummary") ⇒ Object 



1750
1751
1752
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1750

def self.image_summary(tag, tensor, max_images: 3, typeT: :float, bad_color: [], name: "ImageSummary")
  self.execute("ImageSummary", [tag, tensor], max_images: max_images, T: typeT, bad_color: bad_color, name: name)
end

.immutable_const(dtype: nil, shape: nil, memory_region_name: "", name: "ImmutableConst") ⇒ Object 



1754
1755
1756
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1754

def self.immutable_const(dtype: nil, shape: nil, memory_region_name: "", name: "ImmutableConst")
  self.execute("ImmutableConst", [], dtype: dtype, shape: shape, memory_region_name: memory_region_name, name: name)
end

.import_event(writer, event, name: "ImportEvent") ⇒ Object 



1758
1759
1760
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1758

def self.import_event(writer, event, name: "ImportEvent")
  self.execute("ImportEvent", [writer, event], name: name)
end

.in_top_k(predictions, targets, k: nil, typeT: :int32, name: "InTopK") ⇒ Object 



1762
1763
1764
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1762

def self.in_top_k(predictions, targets, k: nil, typeT: :int32, name: "InTopK")
  self.execute("InTopK", [predictions, targets], k: k, T: typeT, name: name)
end

.in_top_kv2(predictions, targets, k, typeT: :int32, name: "InTopKV2") ⇒ Object 



1766
1767
1768
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1766

def self.in_top_kv2(predictions, targets, k, typeT: :int32, name: "InTopKV2")
  self.execute("InTopKV2", [predictions, targets, k], T: typeT, name: name)
end

.infeed_dequeue(dtype: nil, shape: nil, name: "InfeedDequeue") ⇒ Object 



1770
1771
1772
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1770

def self.infeed_dequeue(dtype: nil, shape: nil, name: "InfeedDequeue")
  self.execute("InfeedDequeue", [], dtype: dtype, shape: shape, name: name)
end

.infeed_dequeue_tuple(dtypes: nil, shapes: nil, name: "InfeedDequeueTuple") ⇒ Object 



1774
1775
1776
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1774

def self.infeed_dequeue_tuple(dtypes: nil, shapes: nil, name: "InfeedDequeueTuple")
  self.execute("InfeedDequeueTuple", [], dtypes: dtypes, shapes: shapes, name: name)
end

.infeed_enqueue(input, dtype: nil, shape: [], layout: [], device_ordinal: -1,, name: "InfeedEnqueue") ⇒ Object 



1778
1779
1780
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1778

def self.infeed_enqueue(input, dtype: nil, shape: [], layout: [], device_ordinal: -1, name: "InfeedEnqueue")
  self.execute("InfeedEnqueue", [input], dtype: dtype, shape: shape, layout: layout, device_ordinal: device_ordinal, name: name)
end

.infeed_enqueue_prelinearized_buffer(input, device_ordinal: -1,, name: "InfeedEnqueuePrelinearizedBuffer") ⇒ Object 



1782
1783
1784
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1782

def self.infeed_enqueue_prelinearized_buffer(input, device_ordinal: -1, name: "InfeedEnqueuePrelinearizedBuffer")
  self.execute("InfeedEnqueuePrelinearizedBuffer", [input], device_ordinal: device_ordinal, name: name)
end

.infeed_enqueue_tuple(inputs, dtypes: nil, shapes: nil, layouts: [], device_ordinal: -1,, name: "InfeedEnqueueTuple") ⇒ Object 



1786
1787
1788
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1786

def self.infeed_enqueue_tuple(inputs, dtypes: nil, shapes: nil, layouts: [], device_ordinal: -1, name: "InfeedEnqueueTuple")
  self.execute("InfeedEnqueueTuple", [inputs], dtypes: dtypes, shapes: shapes, layouts: layouts, device_ordinal: device_ordinal, name: name)
end

.initialize_table(table_handle, keys, values, tkey: nil, tval: nil, name: "InitializeTable") ⇒ Object 



1790
1791
1792
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1790

def self.initialize_table(table_handle, keys, values, tkey: nil, tval: nil, name: "InitializeTable")
  self.execute("InitializeTable", [table_handle, keys, values], Tkey: tkey, Tval: tval, name: name)
end

.initialize_table_from_text_file(table_handle, filename, key_index: nil, value_index: nil, vocab_size: -1,, delimiter: " ", name: "InitializeTableFromTextFile") ⇒ Object 



1794
1795
1796
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1794

def self.initialize_table_from_text_file(table_handle, filename, key_index: nil, value_index: nil, vocab_size: -1, delimiter: "	", name: "InitializeTableFromTextFile")
  self.execute("InitializeTableFromTextFile", [table_handle, filename], key_index: key_index, value_index: value_index, vocab_size: vocab_size, delimiter: delimiter, name: name)
end

.initialize_table_from_text_file_v2(table_handle, filename, key_index: nil, value_index: nil, vocab_size: -1,, delimiter: " ", name: "InitializeTableFromTextFileV2") ⇒ Object 



1798
1799
1800
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1798

def self.initialize_table_from_text_file_v2(table_handle, filename, key_index: nil, value_index: nil, vocab_size: -1, delimiter: "	", name: "InitializeTableFromTextFileV2")
  self.execute("InitializeTableFromTextFileV2", [table_handle, filename], key_index: key_index, value_index: value_index, vocab_size: vocab_size, delimiter: delimiter, name: name)
end

.initialize_table_v2(table_handle, keys, values, tkey: nil, tval: nil, name: "InitializeTableV2") ⇒ Object 



1802
1803
1804
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1802

def self.initialize_table_v2(table_handle, keys, values, tkey: nil, tval: nil, name: "InitializeTableV2")
  self.execute("InitializeTableV2", [table_handle, keys, values], Tkey: tkey, Tval: tval, name: name)
end

.inplace_add(x, i, v, typeT: nil, name: "InplaceAdd") ⇒ Object 



1806
1807
1808
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1806

def self.inplace_add(x, i, v, typeT: nil, name: "InplaceAdd")
  self.execute("InplaceAdd", [x, i, v], T: typeT, name: name)
end

.inplace_sub(x, i, v, typeT: nil, name: "InplaceSub") ⇒ Object 



1810
1811
1812
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1810

def self.inplace_sub(x, i, v, typeT: nil, name: "InplaceSub")
  self.execute("InplaceSub", [x, i, v], T: typeT, name: name)
end

.inplace_update(x, i, v, typeT: nil, name: "InplaceUpdate") ⇒ Object 



1814
1815
1816
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1814

def self.inplace_update(x, i, v, typeT: nil, name: "InplaceUpdate")
  self.execute("InplaceUpdate", [x, i, v], T: typeT, name: name)
end

.interleave_dataset(input_dataset, other_arguments, cycle_length, block_length, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "InterleaveDataset") ⇒ Object 



1818
1819
1820
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1818

def self.interleave_dataset(input_dataset, other_arguments, cycle_length, block_length, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "InterleaveDataset")
  self.execute("InterleaveDataset", [input_dataset, other_arguments, cycle_length, block_length], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.inv(x, typeT: nil, name: "Inv") ⇒ Object 



1822
1823
1824
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1822

def self.inv(x, typeT: nil, name: "Inv")
  self.execute("Inv", [x], T: typeT, name: name)
end

.inv_grad(y, dy, typeT: nil, name: "InvGrad") ⇒ Object 



1826
1827
1828
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1826

def self.inv_grad(y, dy, typeT: nil, name: "InvGrad")
  self.execute("InvGrad", [y, dy], T: typeT, name: name)
end

.invert(x, typeT: nil, name: "Invert") ⇒ Object 



1830
1831
1832
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1830

def self.invert(x, typeT: nil, name: "Invert")
  self.execute("Invert", [x], T: typeT, name: name)
end

.invert_permutation(x, typeT: :int32, name: "InvertPermutation") ⇒ Object 



1834
1835
1836
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1834

def self.invert_permutation(x, typeT: :int32, name: "InvertPermutation")
  self.execute("InvertPermutation", [x], T: typeT, name: name)
end

.irfft(input, fft_length, treal: :float, tcomplex: :complex64, name: "IRFFT") ⇒ Object 



1698
1699
1700
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1698

def self.irfft(input, fft_length, treal: :float, tcomplex: :complex64, name: "IRFFT")
  self.execute("IRFFT", [input, fft_length], Treal: treal, Tcomplex: tcomplex, name: name)
end

.irfft2_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "IRFFT2D") ⇒ Object 



1702
1703
1704
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1702

def self.irfft2_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "IRFFT2D")
  self.execute("IRFFT2D", [input, fft_length], Treal: treal, Tcomplex: tcomplex, name: name)
end

.irfft3_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "IRFFT3D") ⇒ Object 



1706
1707
1708
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1706

def self.irfft3_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "IRFFT3D")
  self.execute("IRFFT3D", [input, fft_length], Treal: treal, Tcomplex: tcomplex, name: name)
end

.is_boosted_trees_ensemble_initialized(tree_ensemble_handle, name: "IsBoostedTreesEnsembleInitialized") ⇒ Object 



1838
1839
1840
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1838

def self.is_boosted_trees_ensemble_initialized(tree_ensemble_handle, name: "IsBoostedTreesEnsembleInitialized")
  self.execute("IsBoostedTreesEnsembleInitialized", [tree_ensemble_handle], name: name)
end

.is_boosted_trees_quantile_stream_resource_initialized(quantile_stream_resource_handle, name: "IsBoostedTreesQuantileStreamResourceInitialized") ⇒ Object 



1842
1843
1844
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1842

def self.is_boosted_trees_quantile_stream_resource_initialized(quantile_stream_resource_handle, name: "IsBoostedTreesQuantileStreamResourceInitialized")
  self.execute("IsBoostedTreesQuantileStreamResourceInitialized", [quantile_stream_resource_handle], name: name)
end

.is_finite(x, typeT: nil, name: "IsFinite") ⇒ Object 



1846
1847
1848
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1846

def self.is_finite(x, typeT: nil, name: "IsFinite")
  self.execute("IsFinite", [x], T: typeT, name: name)
end

.is_inf(x, typeT: nil, name: "IsInf") ⇒ Object 



1850
1851
1852
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1850

def self.is_inf(x, typeT: nil, name: "IsInf")
  self.execute("IsInf", [x], T: typeT, name: name)
end

.is_nan(x, typeT: nil, name: "IsNan") ⇒ Object 



1854
1855
1856
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1854

def self.is_nan(x, typeT: nil, name: "IsNan")
  self.execute("IsNan", [x], T: typeT, name: name)
end

.is_variable_initialized(ref, dtype: nil, name: "IsVariableInitialized") ⇒ Object 



1858
1859
1860
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1858

def self.is_variable_initialized(ref, dtype: nil, name: "IsVariableInitialized")
  self.execute("IsVariableInitialized", [ref], dtype: dtype, name: name)
end

.iterator(shared_name: "", container: "", output_types: nil, output_shapes: nil, name: "Iterator") ⇒ Object 



1862
1863
1864
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1862

def self.iterator(shared_name: "", container: "", output_types: nil, output_shapes: nil, name: "Iterator")
  self.execute("Iterator", [], shared_name: shared_name, container: container, output_types: output_types, output_shapes: output_shapes, name: name)
end

.iterator_from_string_handle(string_handle, output_types: [], output_shapes: [], name: "IteratorFromStringHandle") ⇒ Object 



1866
1867
1868
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1866

def self.iterator_from_string_handle(string_handle, output_types: [], output_shapes: [], name: "IteratorFromStringHandle")
  self.execute("IteratorFromStringHandle", [string_handle], output_types: output_types, output_shapes: output_shapes, name: name)
end

.iterator_from_string_handle_v2(string_handle, output_types: [], output_shapes: [], name: "IteratorFromStringHandleV2") ⇒ Object 



1870
1871
1872
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1870

def self.iterator_from_string_handle_v2(string_handle, output_types: [], output_shapes: [], name: "IteratorFromStringHandleV2")
  self.execute("IteratorFromStringHandleV2", [string_handle], output_types: output_types, output_shapes: output_shapes, name: name)
end

.iterator_get_device(resource, name: "IteratorGetDevice") ⇒ Object 



1874
1875
1876
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1874

def self.iterator_get_device(resource, name: "IteratorGetDevice")
  self.execute("IteratorGetDevice", [resource], name: name)
end

.iterator_get_next(iterator, output_types: nil, output_shapes: nil, name: "IteratorGetNext") ⇒ Object 



1878
1879
1880
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1878

def self.iterator_get_next(iterator, output_types: nil, output_shapes: nil, name: "IteratorGetNext")
  self.execute("IteratorGetNext", [iterator], output_types: output_types, output_shapes: output_shapes, name: name)
end

.iterator_get_next_as_optional(iterator, output_types: nil, output_shapes: nil, name: "IteratorGetNextAsOptional") ⇒ Object 



1882
1883
1884
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1882

def self.iterator_get_next_as_optional(iterator, output_types: nil, output_shapes: nil, name: "IteratorGetNextAsOptional")
  self.execute("IteratorGetNextAsOptional", [iterator], output_types: output_types, output_shapes: output_shapes, name: name)
end

.iterator_get_next_sync(iterator, output_types: nil, output_shapes: nil, name: "IteratorGetNextSync") ⇒ Object 



1886
1887
1888
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1886

def self.iterator_get_next_sync(iterator, output_types: nil, output_shapes: nil, name: "IteratorGetNextSync")
  self.execute("IteratorGetNextSync", [iterator], output_types: output_types, output_shapes: output_shapes, name: name)
end

.iterator_to_string_handle(resource_handle, name: "IteratorToStringHandle") ⇒ Object 



1890
1891
1892
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1890

def self.iterator_to_string_handle(resource_handle, name: "IteratorToStringHandle")
  self.execute("IteratorToStringHandle", [resource_handle], name: name)
end

.iterator_v2(shared_name: "", container: "", output_types: nil, output_shapes: nil, name: "IteratorV2") ⇒ Object 



1894
1895
1896
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1894

def self.iterator_v2(shared_name: "", container: "", output_types: nil, output_shapes: nil, name: "IteratorV2")
  self.execute("IteratorV2", [], shared_name: shared_name, container: container, output_types: output_types, output_shapes: output_shapes, name: name)
end

.kmc2_chain_initialization(distances, seed, name: "KMC2ChainInitialization") ⇒ Object 



1898
1899
1900
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1898

def self.kmc2_chain_initialization(distances, seed, name: "KMC2ChainInitialization")
  self.execute("KMC2ChainInitialization", [distances, seed], name: name)
end

.kmeans_plus_plus_initialization(points, num_to_sample, seed, num_retries_per_sample, name: "KmeansPlusPlusInitialization") ⇒ Object 



1902
1903
1904
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1902

def self.kmeans_plus_plus_initialization(points, num_to_sample, seed, num_retries_per_sample, name: "KmeansPlusPlusInitialization")
  self.execute("KmeansPlusPlusInitialization", [points, num_to_sample, seed, num_retries_per_sample], name: name)
end

.l2_loss(t, typeT: nil, name: "L2Loss") ⇒ Object 



1906
1907
1908
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1906

def self.l2_loss(t, typeT: nil, name: "L2Loss")
  self.execute("L2Loss", [t], T: typeT, name: name)
end

.latency_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "LatencyStatsDataset") ⇒ Object 



1934
1935
1936
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1934

def self.latency_stats_dataset(input_dataset, tag, output_types: nil, output_shapes: nil, name: "LatencyStatsDataset")
  self.execute("LatencyStatsDataset", [input_dataset, tag], output_types: output_types, output_shapes: output_shapes, name: name)
end

.leaky_relu(features, alpha: 0.20000000298023224, typeT: :float, name: "LeakyRelu") ⇒ Object 



1938
1939
1940
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1938

def self.leaky_relu(features, alpha: 0.20000000298023224, typeT: :float, name: "LeakyRelu")
  self.execute("LeakyRelu", [features], alpha: alpha, T: typeT, name: name)
end

.leaky_relu_grad(gradients, features, alpha: 0.20000000298023224, typeT: :float, name: "LeakyReluGrad") ⇒ Object 



1942
1943
1944
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1942

def self.leaky_relu_grad(gradients, features, alpha: 0.20000000298023224, typeT: :float, name: "LeakyReluGrad")
  self.execute("LeakyReluGrad", [gradients, features], alpha: alpha, T: typeT, name: name)
end

.learned_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "LearnedUnigramCandidateSampler") ⇒ Object 



1946
1947
1948
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1946

def self.learned_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "LearnedUnigramCandidateSampler")
  self.execute("LearnedUnigramCandidateSampler", [true_classes], num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, seed: seed, seed2: seed2, name: name)
end

.left_shift(x, y, typeT: nil, name: "LeftShift") ⇒ Object 



1950
1951
1952
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1950

def self.left_shift(x, y, typeT: nil, name: "LeftShift")
  self.execute("LeftShift", [x, y], T: typeT, name: name)
end

.less(x, y, typeT: nil, name: "Less") ⇒ Object 



1954
1955
1956
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1954

def self.less(x, y, typeT: nil, name: "Less")
  self.execute("Less", [x, y], T: typeT, name: name)
end

.less_equal(x, y, typeT: nil, name: "LessEqual") ⇒ Object 



1958
1959
1960
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1958

def self.less_equal(x, y, typeT: nil, name: "LessEqual")
  self.execute("LessEqual", [x, y], T: typeT, name: name)
end

.lgamma(x, typeT: nil, name: "Lgamma") ⇒ Object 



1962
1963
1964
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1962

def self.lgamma(x, typeT: nil, name: "Lgamma")
  self.execute("Lgamma", [x], T: typeT, name: name)
end

.lin_space(start, stop, num, typeT: nil, tidx: :int32, name: "LinSpace") ⇒ Object 



1966
1967
1968
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1966

def self.lin_space(start, stop, num, typeT: nil, tidx: :int32, name: "LinSpace")
  self.execute("LinSpace", [start, stop, num], T: typeT, Tidx: tidx, name: name)
end

.list_diff(x, y, typeT: nil, out_idx: :int32, name: "ListDiff") ⇒ Object 



1970
1971
1972
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1970

def self.list_diff(x, y, typeT: nil, out_idx: :int32, name: "ListDiff")
  self.execute("ListDiff", [x, y], T: typeT, out_idx: out_idx, name: name)
end

.lmdb_dataset(filenames, output_types: nil, output_shapes: nil, name: "LMDBDataset") ⇒ Object 



1910
1911
1912
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1910

def self.lmdb_dataset(filenames, output_types: nil, output_shapes: nil, name: "LMDBDataset")
  self.execute("LMDBDataset", [filenames], output_types: output_types, output_shapes: output_shapes, name: name)
end

.lmdb_reader(container: "", shared_name: "", name: "LMDBReader") ⇒ Object 



1914
1915
1916
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1914

def self.lmdb_reader(container: "", shared_name: "", name: "LMDBReader")
  self.execute("LMDBReader", [], container: container, shared_name: shared_name, name: name)
end

.load_and_remap_matrix(ckpt_path, old_tensor_name, row_remapping, col_remapping, initializing_values, num_rows: nil, num_cols: nil, max_rows_in_memory: -1,, name: "LoadAndRemapMatrix") ⇒ Object 



1974
1975
1976
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1974

def self.load_and_remap_matrix(ckpt_path, old_tensor_name, row_remapping, col_remapping, initializing_values, num_rows: nil, num_cols: nil, max_rows_in_memory: -1, name: "LoadAndRemapMatrix")
  self.execute("LoadAndRemapMatrix", [ckpt_path, old_tensor_name, row_remapping, col_remapping, initializing_values], num_rows: num_rows, num_cols: num_cols, max_rows_in_memory: max_rows_in_memory, name: name)
end

.load_tpu_embedding_adadelta_parameters(parameters, accumulators, updates, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdadeltaParameters") ⇒ Object 



1986
1987
1988
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1986

def self.load_tpu_embedding_adadelta_parameters(parameters, accumulators, updates, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdadeltaParameters")
  self.execute("LoadTPUEmbeddingAdadeltaParameters", [parameters, accumulators, updates], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_adadelta_parameters_grad_accum_debug(parameters, accumulators, updates, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdadeltaParametersGradAccumDebug") ⇒ Object 



1990
1991
1992
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1990

def self.load_tpu_embedding_adadelta_parameters_grad_accum_debug(parameters, accumulators, updates, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdadeltaParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingAdadeltaParametersGradAccumDebug", [parameters, accumulators, updates, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_adagrad_parameters(parameters, accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdagradParameters") ⇒ Object 



1994
1995
1996
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1994

def self.load_tpu_embedding_adagrad_parameters(parameters, accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdagradParameters")
  self.execute("LoadTPUEmbeddingAdagradParameters", [parameters, accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_adagrad_parameters_grad_accum_debug(parameters, accumulators, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdagradParametersGradAccumDebug") ⇒ Object 



1998
1999
2000
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1998

def self.load_tpu_embedding_adagrad_parameters_grad_accum_debug(parameters, accumulators, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingAdagradParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingAdagradParametersGradAccumDebug", [parameters, accumulators, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_adam_parameters(parameters, momenta, velocities, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingADAMParameters") ⇒ Object 



1978
1979
1980
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1978

def self.load_tpu_embedding_adam_parameters(parameters, momenta, velocities, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingADAMParameters")
  self.execute("LoadTPUEmbeddingADAMParameters", [parameters, momenta, velocities], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_adam_parameters_grad_accum_debug(parameters, momenta, velocities, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingADAMParametersGradAccumDebug") ⇒ Object 



1982
1983
1984
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1982

def self.load_tpu_embedding_adam_parameters_grad_accum_debug(parameters, momenta, velocities, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingADAMParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingADAMParametersGradAccumDebug", [parameters, momenta, velocities, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_centered_rms_prop_parameters(parameters, ms, mom, mg, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingCenteredRMSPropParameters") ⇒ Object 



2002
2003
2004
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2002

def self.load_tpu_embedding_centered_rms_prop_parameters(parameters, ms, mom, mg, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingCenteredRMSPropParameters")
  self.execute("LoadTPUEmbeddingCenteredRMSPropParameters", [parameters, ms, mom, mg], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_ftrl_parameters(parameters, accumulators, linears, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingFTRLParameters") ⇒ Object 



2006
2007
2008
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2006

def self.load_tpu_embedding_ftrl_parameters(parameters, accumulators, linears, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingFTRLParameters")
  self.execute("LoadTPUEmbeddingFTRLParameters", [parameters, accumulators, linears], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_ftrl_parameters_grad_accum_debug(parameters, accumulators, linears, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingFTRLParametersGradAccumDebug") ⇒ Object 



2010
2011
2012
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2010

def self.load_tpu_embedding_ftrl_parameters_grad_accum_debug(parameters, accumulators, linears, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingFTRLParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingFTRLParametersGradAccumDebug", [parameters, accumulators, linears, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_mdl_adagrad_light_parameters(parameters, accumulators, weights, benefits, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingMDLAdagradLightParameters") ⇒ Object 



2014
2015
2016
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2014

def self.load_tpu_embedding_mdl_adagrad_light_parameters(parameters, accumulators, weights, benefits, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingMDLAdagradLightParameters")
  self.execute("LoadTPUEmbeddingMDLAdagradLightParameters", [parameters, accumulators, weights, benefits], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_momentum_parameters(parameters, momenta, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingMomentumParameters") ⇒ Object 



2018
2019
2020
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2018

def self.load_tpu_embedding_momentum_parameters(parameters, momenta, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingMomentumParameters")
  self.execute("LoadTPUEmbeddingMomentumParameters", [parameters, momenta], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_momentum_parameters_grad_accum_debug(parameters, momenta, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingMomentumParametersGradAccumDebug") ⇒ Object 



2022
2023
2024
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2022

def self.load_tpu_embedding_momentum_parameters_grad_accum_debug(parameters, momenta, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingMomentumParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingMomentumParametersGradAccumDebug", [parameters, momenta, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_proximal_adagrad_parameters(parameters, accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingProximalAdagradParameters") ⇒ Object 



2026
2027
2028
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2026

def self.load_tpu_embedding_proximal_adagrad_parameters(parameters, accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingProximalAdagradParameters")
  self.execute("LoadTPUEmbeddingProximalAdagradParameters", [parameters, accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_proximal_adagrad_parameters_grad_accum_debug(parameters, accumulators, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug") ⇒ Object 



2030
2031
2032
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2030

def self.load_tpu_embedding_proximal_adagrad_parameters_grad_accum_debug(parameters, accumulators, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug", [parameters, accumulators, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_rms_prop_parameters(parameters, ms, mom, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingRMSPropParameters") ⇒ Object 



2034
2035
2036
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2034

def self.load_tpu_embedding_rms_prop_parameters(parameters, ms, mom, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingRMSPropParameters")
  self.execute("LoadTPUEmbeddingRMSPropParameters", [parameters, ms, mom], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_rms_prop_parameters_grad_accum_debug(parameters, ms, mom, gradient_accumulators, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingRMSPropParametersGradAccumDebug") ⇒ Object 



2038
2039
2040
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2038

def self.load_tpu_embedding_rms_prop_parameters_grad_accum_debug(parameters, ms, mom, gradient_accumulators, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingRMSPropParametersGradAccumDebug")
  self.execute("LoadTPUEmbeddingRMSPropParametersGradAccumDebug", [parameters, ms, mom, gradient_accumulators], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.load_tpu_embedding_stochastic_gradient_descent_parameters(parameters, table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingStochasticGradientDescentParameters") ⇒ Object 



2042
2043
2044
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2042

def self.load_tpu_embedding_stochastic_gradient_descent_parameters(parameters, table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "LoadTPUEmbeddingStochasticGradientDescentParameters")
  self.execute("LoadTPUEmbeddingStochasticGradientDescentParameters", [parameters], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.log(x, typeT: nil, name: "Log") ⇒ Object 



2046
2047
2048
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2046

def self.log(x, typeT: nil, name: "Log")
  self.execute("Log", [x], T: typeT, name: name)
end

.log1p(x, typeT: nil, name: "Log1p") ⇒ Object 



2050
2051
2052
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2050

def self.log1p(x, typeT: nil, name: "Log1p")
  self.execute("Log1p", [x], T: typeT, name: name)
end

.log_matrix_determinant(input, typeT: nil, name: "LogMatrixDeterminant") ⇒ Object 



2054
2055
2056
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2054

def self.log_matrix_determinant(input, typeT: nil, name: "LogMatrixDeterminant")
  self.execute("LogMatrixDeterminant", [input], T: typeT, name: name)
end

.log_softmax(logits, typeT: nil, name: "LogSoftmax") ⇒ Object 



2058
2059
2060
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2058

def self.log_softmax(logits, typeT: nil, name: "LogSoftmax")
  self.execute("LogSoftmax", [logits], T: typeT, name: name)
end

.log_uniform_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "LogUniformCandidateSampler") ⇒ Object 



2062
2063
2064
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2062

def self.log_uniform_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "LogUniformCandidateSampler")
  self.execute("LogUniformCandidateSampler", [true_classes], num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, seed: seed, seed2: seed2, name: name)
end

.logical_and(x, y, name: "LogicalAnd") ⇒ Object 



2066
2067
2068
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2066

def self.logical_and(x, y, name: "LogicalAnd")
  self.execute("LogicalAnd", [x, y], name: name)
end

.logical_not(x, name: "LogicalNot") ⇒ Object 



2070
2071
2072
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2070

def self.logical_not(x, name: "LogicalNot")
  self.execute("LogicalNot", [x], name: name)
end

.logical_or(x, y, name: "LogicalOr") ⇒ Object 



2074
2075
2076
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2074

def self.logical_or(x, y, name: "LogicalOr")
  self.execute("LogicalOr", [x, y], name: name)
end

.lookup_table_export(table_handle, tkeys: nil, tvalues: nil, name: "LookupTableExport") ⇒ Object 



2078
2079
2080
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2078

def self.lookup_table_export(table_handle, tkeys: nil, tvalues: nil, name: "LookupTableExport")
  self.execute("LookupTableExport", [table_handle], Tkeys: tkeys, Tvalues: tvalues, name: name)
end

.lookup_table_export_v2(table_handle, tkeys: nil, tvalues: nil, name: "LookupTableExportV2") ⇒ Object 



2082
2083
2084
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2082

def self.lookup_table_export_v2(table_handle, tkeys: nil, tvalues: nil, name: "LookupTableExportV2")
  self.execute("LookupTableExportV2", [table_handle], Tkeys: tkeys, Tvalues: tvalues, name: name)
end

.lookup_table_find(table_handle, keys, default_value, tin: nil, tout: nil, name: "LookupTableFind") ⇒ Object 



2086
2087
2088
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2086

def self.lookup_table_find(table_handle, keys, default_value, tin: nil, tout: nil, name: "LookupTableFind")
  self.execute("LookupTableFind", [table_handle, keys, default_value], Tin: tin, Tout: tout, name: name)
end

.lookup_table_find_v2(table_handle, keys, default_value, tin: nil, tout: nil, name: "LookupTableFindV2") ⇒ Object 



2090
2091
2092
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2090

def self.lookup_table_find_v2(table_handle, keys, default_value, tin: nil, tout: nil, name: "LookupTableFindV2")
  self.execute("LookupTableFindV2", [table_handle, keys, default_value], Tin: tin, Tout: tout, name: name)
end

.lookup_table_import(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableImport") ⇒ Object 



2094
2095
2096
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2094

def self.lookup_table_import(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableImport")
  self.execute("LookupTableImport", [table_handle, keys, values], Tin: tin, Tout: tout, name: name)
end

.lookup_table_import_v2(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableImportV2") ⇒ Object 



2098
2099
2100
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2098

def self.lookup_table_import_v2(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableImportV2")
  self.execute("LookupTableImportV2", [table_handle, keys, values], Tin: tin, Tout: tout, name: name)
end

.lookup_table_insert(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableInsert") ⇒ Object 



2102
2103
2104
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2102

def self.lookup_table_insert(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableInsert")
  self.execute("LookupTableInsert", [table_handle, keys, values], Tin: tin, Tout: tout, name: name)
end

.lookup_table_insert_v2(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableInsertV2") ⇒ Object 



2106
2107
2108
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2106

def self.lookup_table_insert_v2(table_handle, keys, values, tin: nil, tout: nil, name: "LookupTableInsertV2")
  self.execute("LookupTableInsertV2", [table_handle, keys, values], Tin: tin, Tout: tout, name: name)
end

.lookup_table_remove_v2(table_handle, keys, tin: nil, name: "LookupTableRemoveV2") ⇒ Object 



2110
2111
2112
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2110

def self.lookup_table_remove_v2(table_handle, keys, tin: nil, name: "LookupTableRemoveV2")
  self.execute("LookupTableRemoveV2", [table_handle, keys], Tin: tin, name: name)
end

.lookup_table_size(table_handle, name: "LookupTableSize") ⇒ Object 



2114
2115
2116
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2114

def self.lookup_table_size(table_handle, name: "LookupTableSize")
  self.execute("LookupTableSize", [table_handle], name: name)
end

.lookup_table_size_v2(table_handle, name: "LookupTableSizeV2") ⇒ Object 



2118
2119
2120
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2118

def self.lookup_table_size_v2(table_handle, name: "LookupTableSizeV2")
  self.execute("LookupTableSizeV2", [table_handle], name: name)
end

.loop_cond(input, name: "LoopCond") ⇒ Object 



2122
2123
2124
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2122

def self.loop_cond(input, name: "LoopCond")
  self.execute("LoopCond", [input], name: name)
end

.lower_bound(sorted_inputs, values, typeT: nil, out_type: :int32, name: "LowerBound") ⇒ Object 



2126
2127
2128
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2126

def self.lower_bound(sorted_inputs, values, typeT: nil, out_type: :int32, name: "LowerBound")
  self.execute("LowerBound", [sorted_inputs, values], T: typeT, out_type: out_type, name: name)
end

.lrn(input, depth_radius: 5, bias: 1.0, alpha: 1.0, beta: 0.5, typeT: :float, name: "LRN") ⇒ Object 



1918
1919
1920
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1918

def self.lrn(input, depth_radius: 5, bias: 1.0, alpha: 1.0, beta: 0.5, typeT: :float, name: "LRN")
  self.execute("LRN", [input], depth_radius: depth_radius, bias: bias, alpha: alpha, beta: beta, T: typeT, name: name)
end

.lrn_grad(input_grads, input_image, output_image, depth_radius: 5, bias: 1.0, alpha: 1.0, beta: 0.5, typeT: :float, name: "LRNGrad") ⇒ Object 



1922
1923
1924
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1922

def self.lrn_grad(input_grads, input_image, output_image, depth_radius: 5, bias: 1.0, alpha: 1.0, beta: 0.5, typeT: :float, name: "LRNGrad")
  self.execute("LRNGrad", [input_grads, input_image, output_image], depth_radius: depth_radius, bias: bias, alpha: alpha, beta: beta, T: typeT, name: name)
end

.lstm_block_cell(x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias: 1.0, cell_clip: 3.0, use_peephole: false, typeT: nil, name: "LSTMBlockCell") ⇒ Object 



1926
1927
1928
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1926

def self.lstm_block_cell(x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias: 1.0, cell_clip: 3.0, use_peephole: false, typeT: nil, name: "LSTMBlockCell")
  self.execute("LSTMBlockCell", [x, cs_prev, h_prev, w, wci, wcf, wco, b], forget_bias: forget_bias, cell_clip: cell_clip, use_peephole: use_peephole, T: typeT, name: name)
end

.lstm_block_cell_grad(x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, use_peephole: nil, typeT: nil, name: "LSTMBlockCellGrad") ⇒ Object 



1930
1931
1932
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 1930

def self.lstm_block_cell_grad(x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, use_peephole: nil, typeT: nil, name: "LSTMBlockCellGrad")
  self.execute("LSTMBlockCellGrad", [x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad], use_peephole: use_peephole, T: typeT, name: name)
end

.lu(input, typeT: nil, output_idx_type: :int32, name: "Lu") ⇒ Object 



2130
2131
2132
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2130

def self.lu(input, typeT: nil, output_idx_type: :int32, name: "Lu")
  self.execute("Lu", [input], T: typeT, output_idx_type: output_idx_type, name: name)
end

.make_iterator(dataset, iterator, name: "MakeIterator") ⇒ Object 



2134
2135
2136
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2134

def self.make_iterator(dataset, iterator, name: "MakeIterator")
  self.execute("MakeIterator", [dataset, iterator], name: name)
end

.map_and_batch_dataset(input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, f: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, name: "MapAndBatchDataset") ⇒ Object 



2138
2139
2140
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2138

def self.map_and_batch_dataset(input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, f: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, name: "MapAndBatchDataset")
  self.execute("MapAndBatchDataset", [input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, preserve_cardinality: preserve_cardinality, name: name)
end

.map_clear(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapClear") ⇒ Object 



2142
2143
2144
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2142

def self.map_clear(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapClear")
  self.execute("MapClear", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.map_dataset(input_dataset, other_arguments, f: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, preserve_cardinality: false, name: "MapDataset") ⇒ Object 



2146
2147
2148
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2146

def self.map_dataset(input_dataset, other_arguments, f: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, preserve_cardinality: false, name: "MapDataset")
  self.execute("MapDataset", [input_dataset, other_arguments], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, use_inter_op_parallelism: use_inter_op_parallelism, preserve_cardinality: preserve_cardinality, name: name)
end

.map_defun(arguments, captured_inputs, targuments: nil, tcaptured: [], output_types: nil, output_shapes: nil, f: nil, max_intra_op_parallelism: 1, name: "MapDefun") ⇒ Object 



2150
2151
2152
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2150

def self.map_defun(arguments, captured_inputs, targuments: nil, tcaptured: [], output_types: nil, output_shapes: nil, f: nil, max_intra_op_parallelism: 1, name: "MapDefun")
  self.execute("MapDefun", [arguments, captured_inputs], Targuments: targuments, Tcaptured: tcaptured, output_types: output_types, output_shapes: output_shapes, f: f, max_intra_op_parallelism: max_intra_op_parallelism, name: name)
end

.map_incomplete_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapIncompleteSize") ⇒ Object 



2154
2155
2156
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2154

def self.map_incomplete_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapIncompleteSize")
  self.execute("MapIncompleteSize", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.map_peek(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapPeek") ⇒ Object 



2158
2159
2160
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2158

def self.map_peek(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapPeek")
  self.execute("MapPeek", [key, indices], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.map_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapSize") ⇒ Object 



2162
2163
2164
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2162

def self.map_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapSize")
  self.execute("MapSize", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.map_stage(key, indices, values, capacity: 0, memory_limit: 0, dtypes: nil, fake_dtypes: nil, container: "", shared_name: "", name: "MapStage") ⇒ Object 



2166
2167
2168
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2166

def self.map_stage(key, indices, values, capacity: 0, memory_limit: 0, dtypes: nil, fake_dtypes: nil, container: "", shared_name: "", name: "MapStage")
  self.execute("MapStage", [key, indices, values], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, fake_dtypes: fake_dtypes, container: container, shared_name: shared_name, name: name)
end

.map_unstage(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapUnstage") ⇒ Object 



2170
2171
2172
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2170

def self.map_unstage(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapUnstage")
  self.execute("MapUnstage", [key, indices], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.map_unstage_no_key(indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapUnstageNoKey") ⇒ Object 



2174
2175
2176
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2174

def self.map_unstage_no_key(indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "MapUnstageNoKey")
  self.execute("MapUnstageNoKey", [indices], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.mat_mul(a, b, transpose_a: false, transpose_b: false, typeT: nil, name: "MatMul") ⇒ Object 



2178
2179
2180
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2178

def self.mat_mul(a, b, transpose_a: false, transpose_b: false, typeT: nil, name: "MatMul")
  self.execute("MatMul", [a, b], transpose_a: transpose_a, transpose_b: transpose_b, T: typeT, name: name)
end

.matching_files(pattern, name: "MatchingFiles") ⇒ Object 



2182
2183
2184
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2182

def self.matching_files(pattern, name: "MatchingFiles")
  self.execute("MatchingFiles", [pattern], name: name)
end

.matching_files_dataset(patterns, name: "MatchingFilesDataset") ⇒ Object 



2186
2187
2188
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2186

def self.matching_files_dataset(patterns, name: "MatchingFilesDataset")
  self.execute("MatchingFilesDataset", [patterns], name: name)
end

.matrix_band_part(input, num_lower, num_upper, typeT: nil, tindex: :int64, name: "MatrixBandPart") ⇒ Object 



2190
2191
2192
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2190

def self.matrix_band_part(input, num_lower, num_upper, typeT: nil, tindex: :int64, name: "MatrixBandPart")
  self.execute("MatrixBandPart", [input, num_lower, num_upper], T: typeT, Tindex: tindex, name: name)
end

.matrix_determinant(input, typeT: nil, name: "MatrixDeterminant") ⇒ Object 



2194
2195
2196
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2194

def self.matrix_determinant(input, typeT: nil, name: "MatrixDeterminant")
  self.execute("MatrixDeterminant", [input], T: typeT, name: name)
end

.matrix_diag(diagonal, typeT: nil, name: "MatrixDiag") ⇒ Object 



2198
2199
2200
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2198

def self.matrix_diag(diagonal, typeT: nil, name: "MatrixDiag")
  self.execute("MatrixDiag", [diagonal], T: typeT, name: name)
end

.matrix_diag_part(input, typeT: nil, name: "MatrixDiagPart") ⇒ Object 



2202
2203
2204
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2202

def self.matrix_diag_part(input, typeT: nil, name: "MatrixDiagPart")
  self.execute("MatrixDiagPart", [input], T: typeT, name: name)
end

.matrix_diag_part_v2(input, k, padding_value, typeT: nil, name: "MatrixDiagPartV2") ⇒ Object 



2206
2207
2208
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2206

def self.matrix_diag_part_v2(input, k, padding_value, typeT: nil, name: "MatrixDiagPartV2")
  self.execute("MatrixDiagPartV2", [input, k, padding_value], T: typeT, name: name)
end

.matrix_diag_v2(diagonal, k, num_rows, num_cols, padding_value, typeT: nil, name: "MatrixDiagV2") ⇒ Object 



2210
2211
2212
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2210

def self.matrix_diag_v2(diagonal, k, num_rows, num_cols, padding_value, typeT: nil, name: "MatrixDiagV2")
  self.execute("MatrixDiagV2", [diagonal, k, num_rows, num_cols, padding_value], T: typeT, name: name)
end

.matrix_exponential(input, typeT: nil, name: "MatrixExponential") ⇒ Object 



2214
2215
2216
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2214

def self.matrix_exponential(input, typeT: nil, name: "MatrixExponential")
  self.execute("MatrixExponential", [input], T: typeT, name: name)
end

.matrix_inverse(input, adjoint: false, typeT: nil, name: "MatrixInverse") ⇒ Object 



2218
2219
2220
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2218

def self.matrix_inverse(input, adjoint: false, typeT: nil, name: "MatrixInverse")
  self.execute("MatrixInverse", [input], adjoint: adjoint, T: typeT, name: name)
end

.matrix_logarithm(input, typeT: nil, name: "MatrixLogarithm") ⇒ Object 



2222
2223
2224
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2222

def self.matrix_logarithm(input, typeT: nil, name: "MatrixLogarithm")
  self.execute("MatrixLogarithm", [input], T: typeT, name: name)
end

.matrix_set_diag(input, diagonal, typeT: nil, name: "MatrixSetDiag") ⇒ Object 



2226
2227
2228
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2226

def self.matrix_set_diag(input, diagonal, typeT: nil, name: "MatrixSetDiag")
  self.execute("MatrixSetDiag", [input, diagonal], T: typeT, name: name)
end

.matrix_set_diag_v2(input, diagonal, k, typeT: nil, name: "MatrixSetDiagV2") ⇒ Object 



2230
2231
2232
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2230

def self.matrix_set_diag_v2(input, diagonal, k, typeT: nil, name: "MatrixSetDiagV2")
  self.execute("MatrixSetDiagV2", [input, diagonal, k], T: typeT, name: name)
end

.matrix_solve(matrix, rhs, adjoint: false, typeT: nil, name: "MatrixSolve") ⇒ Object 



2234
2235
2236
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2234

def self.matrix_solve(matrix, rhs, adjoint: false, typeT: nil, name: "MatrixSolve")
  self.execute("MatrixSolve", [matrix, rhs], adjoint: adjoint, T: typeT, name: name)
end

.matrix_solve_ls(matrix, rhs, l2_regularizer, typeT: nil, fast: true, name: "MatrixSolveLs") ⇒ Object 



2238
2239
2240
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2238

def self.matrix_solve_ls(matrix, rhs, l2_regularizer, typeT: nil, fast: true, name: "MatrixSolveLs")
  self.execute("MatrixSolveLs", [matrix, rhs, l2_regularizer], T: typeT, fast: fast, name: name)
end

.matrix_square_root(input, typeT: nil, name: "MatrixSquareRoot") ⇒ Object 



2242
2243
2244
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2242

def self.matrix_square_root(input, typeT: nil, name: "MatrixSquareRoot")
  self.execute("MatrixSquareRoot", [input], T: typeT, name: name)
end

.matrix_triangular_solve(matrix, rhs, lower: true, adjoint: false, typeT: nil, name: "MatrixTriangularSolve") ⇒ Object 



2246
2247
2248
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2246

def self.matrix_triangular_solve(matrix, rhs, lower: true, adjoint: false, typeT: nil, name: "MatrixTriangularSolve")
  self.execute("MatrixTriangularSolve", [matrix, rhs], lower: lower, adjoint: adjoint, T: typeT, name: name)
end

.max(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Max") ⇒ Object 



2250
2251
2252
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2250

def self.max(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Max")
  self.execute("Max", [input, reduction_indices], keep_dims: keep_dims, T: typeT, Tidx: tidx, name: name)
end

.max_intra_op_parallelism_dataset(input_dataset, max_intra_op_parallelism, output_types: nil, output_shapes: nil, name: "MaxIntraOpParallelismDataset") ⇒ Object 



2254
2255
2256
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2254

def self.max_intra_op_parallelism_dataset(input_dataset, max_intra_op_parallelism, output_types: nil, output_shapes: nil, name: "MaxIntraOpParallelismDataset")
  self.execute("MaxIntraOpParallelismDataset", [input_dataset, max_intra_op_parallelism], output_types: output_types, output_shapes: output_shapes, name: name)
end

.max_pool(input, typeT: :float, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", name: "MaxPool") ⇒ Object 



2258
2259
2260
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2258

def self.max_pool(input, typeT: :float, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", name: "MaxPool")
  self.execute("MaxPool", [input], T: typeT, ksize: ksize, strides: strides, padding: padding, data_format: data_format, name: name)
end

.max_pool3_d(input, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "MaxPool3D") ⇒ Object 



2262
2263
2264
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2262

def self.max_pool3_d(input, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "MaxPool3D")
  self.execute("MaxPool3D", [input], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.max_pool3_d_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: :float, tinput: :float, name: "MaxPool3DGrad") ⇒ Object 



2266
2267
2268
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2266

def self.max_pool3_d_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: :float, tinput: :float, name: "MaxPool3DGrad")
  self.execute("MaxPool3DGrad", [orig_input, orig_output, grad], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, TInput: tinput, name: name)
end

.max_pool3_d_grad_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "MaxPool3DGradGrad") ⇒ Object 



2270
2271
2272
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2270

def self.max_pool3_d_grad_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NDHWC", typeT: nil, name: "MaxPool3DGradGrad")
  self.execute("MaxPool3DGradGrad", [orig_input, orig_output, grad], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.max_pool_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: :float, name: "MaxPoolGrad") ⇒ Object 



2274
2275
2276
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2274

def self.max_pool_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: :float, name: "MaxPoolGrad")
  self.execute("MaxPoolGrad", [orig_input, orig_output, grad], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.max_pool_grad_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: nil, name: "MaxPoolGradGrad") ⇒ Object 



2278
2279
2280
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2278

def self.max_pool_grad_grad(orig_input, orig_output, grad, ksize: nil, strides: nil, padding: nil, data_format: "NHWC", typeT: nil, name: "MaxPoolGradGrad")
  self.execute("MaxPoolGradGrad", [orig_input, orig_output, grad], ksize: ksize, strides: strides, padding: padding, data_format: data_format, T: typeT, name: name)
end

.max_pool_grad_grad_v2(orig_input, orig_output, grad, ksize, strides, padding: nil, data_format: "NHWC", typeT: nil, name: "MaxPoolGradGradV2") ⇒ Object 



2282
2283
2284
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2282

def self.max_pool_grad_grad_v2(orig_input, orig_output, grad, ksize, strides, padding: nil, data_format: "NHWC", typeT: nil, name: "MaxPoolGradGradV2")
  self.execute("MaxPoolGradGradV2", [orig_input, orig_output, grad, ksize, strides], padding: padding, data_format: data_format, T: typeT, name: name)
end

.max_pool_grad_grad_with_argmax(input, grad, argmax, ksize: nil, strides: nil, padding: nil, include_batch_in_index: false, targmax: nil, typeT: nil, name: "MaxPoolGradGradWithArgmax") ⇒ Object 



2286
2287
2288
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2286

def self.max_pool_grad_grad_with_argmax(input, grad, argmax, ksize: nil, strides: nil, padding: nil, include_batch_in_index: false, targmax: nil, typeT: nil, name: "MaxPoolGradGradWithArgmax")
  self.execute("MaxPoolGradGradWithArgmax", [input, grad, argmax], ksize: ksize, strides: strides, padding: padding, include_batch_in_index: include_batch_in_index, Targmax: targmax, T: typeT, name: name)
end

.max_pool_grad_v2(orig_input, orig_output, grad, ksize, strides, padding: nil, data_format: "NHWC", typeT: :float, name: "MaxPoolGradV2") ⇒ Object 



2290
2291
2292
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2290

def self.max_pool_grad_v2(orig_input, orig_output, grad, ksize, strides, padding: nil, data_format: "NHWC", typeT: :float, name: "MaxPoolGradV2")
  self.execute("MaxPoolGradV2", [orig_input, orig_output, grad, ksize, strides], padding: padding, data_format: data_format, T: typeT, name: name)
end

.max_pool_grad_with_argmax(input, grad, argmax, ksize: nil, strides: nil, padding: nil, include_batch_in_index: false, targmax: nil, typeT: nil, name: "MaxPoolGradWithArgmax") ⇒ Object 



2294
2295
2296
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2294

def self.max_pool_grad_with_argmax(input, grad, argmax, ksize: nil, strides: nil, padding: nil, include_batch_in_index: false, targmax: nil, typeT: nil, name: "MaxPoolGradWithArgmax")
  self.execute("MaxPoolGradWithArgmax", [input, grad, argmax], ksize: ksize, strides: strides, padding: padding, include_batch_in_index: include_batch_in_index, Targmax: targmax, T: typeT, name: name)
end

.max_pool_v2(input, ksize, strides, typeT: :float, padding: nil, data_format: "NHWC", name: "MaxPoolV2") ⇒ Object 



2298
2299
2300
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2298

def self.max_pool_v2(input, ksize, strides, typeT: :float, padding: nil, data_format: "NHWC", name: "MaxPoolV2")
  self.execute("MaxPoolV2", [input, ksize, strides], T: typeT, padding: padding, data_format: data_format, name: name)
end

.max_pool_with_argmax(input, ksize: nil, strides: nil, targmax: :int64, padding: nil, include_batch_in_index: false, typeT: nil, name: "MaxPoolWithArgmax") ⇒ Object 



2302
2303
2304
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2302

def self.max_pool_with_argmax(input, ksize: nil, strides: nil, targmax: :int64, padding: nil, include_batch_in_index: false, typeT: nil, name: "MaxPoolWithArgmax")
  self.execute("MaxPoolWithArgmax", [input], ksize: ksize, strides: strides, Targmax: targmax, padding: padding, include_batch_in_index: include_batch_in_index, T: typeT, name: name)
end

.maximum(x, y, typeT: nil, name: "Maximum") ⇒ Object 



2306
2307
2308
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2306

def self.maximum(x, y, typeT: nil, name: "Maximum")
  self.execute("Maximum", [x, y], T: typeT, name: name)
end

.mean(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Mean") ⇒ Object 



2310
2311
2312
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2310

def self.mean(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Mean")
  self.execute("Mean", [input, reduction_indices], keep_dims: keep_dims, T: typeT, Tidx: tidx, name: name)
end

.merge(inputs, typeT: nil, n: nil, name: "Merge") ⇒ Object 



2314
2315
2316
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2314

def self.merge(inputs, typeT: nil, n: nil, name: "Merge")
  self.execute("Merge", [inputs], T: typeT, N: n, name: name)
end

.merge_summary(inputs, n: nil, name: "MergeSummary") ⇒ Object 



2318
2319
2320
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2318

def self.merge_summary(inputs, n: nil, name: "MergeSummary")
  self.execute("MergeSummary", [inputs], N: n, name: name)
end

.merge_v2_checkpoints(checkpoint_prefixes, destination_prefix, delete_old_dirs: true, name: "MergeV2Checkpoints") ⇒ Object 



2322
2323
2324
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2322

def self.merge_v2_checkpoints(checkpoint_prefixes, destination_prefix, delete_old_dirs: true, name: "MergeV2Checkpoints")
  self.execute("MergeV2Checkpoints", [checkpoint_prefixes, destination_prefix], delete_old_dirs: delete_old_dirs, name: name)
end

.mfcc(spectrogram, sample_rate, upper_frequency_limit: 4000.0, lower_frequency_limit: 20.0, filterbank_channel_count: 40, dct_coefficient_count: 13, name: "Mfcc") ⇒ Object 



2326
2327
2328
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2326

def self.mfcc(spectrogram, sample_rate, upper_frequency_limit: 4000.0, lower_frequency_limit: 20.0, filterbank_channel_count: 40, dct_coefficient_count: 13, name: "Mfcc")
  self.execute("Mfcc", [spectrogram, sample_rate], upper_frequency_limit: upper_frequency_limit, lower_frequency_limit: lower_frequency_limit, filterbank_channel_count: filterbank_channel_count, dct_coefficient_count: dct_coefficient_count, name: name)
end

.min(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Min") ⇒ Object 



2330
2331
2332
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2330

def self.min(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Min")
  self.execute("Min", [input, reduction_indices], keep_dims: keep_dims, T: typeT, Tidx: tidx, name: name)
end

.minimum(x, y, typeT: nil, name: "Minimum") ⇒ Object 



2334
2335
2336
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2334

def self.minimum(x, y, typeT: nil, name: "Minimum")
  self.execute("Minimum", [x, y], T: typeT, name: name)
end

.mirror_pad(input, paddings, typeT: nil, tpaddings: :int32, mode: nil, name: "MirrorPad") ⇒ Object 



2338
2339
2340
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2338

def self.mirror_pad(input, paddings, typeT: nil, tpaddings: :int32, mode: nil, name: "MirrorPad")
  self.execute("MirrorPad", [input, paddings], T: typeT, Tpaddings: tpaddings, mode: mode, name: name)
end

.mirror_pad_grad(input, paddings, typeT: nil, tpaddings: :int32, mode: nil, name: "MirrorPadGrad") ⇒ Object 



2342
2343
2344
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2342

def self.mirror_pad_grad(input, paddings, typeT: nil, tpaddings: :int32, mode: nil, name: "MirrorPadGrad")
  self.execute("MirrorPadGrad", [input, paddings], T: typeT, Tpaddings: tpaddings, mode: mode, name: name)
end

.mlir_passthrough_op(inputs, mlir_module: "", tinputs: nil, toutputs: nil, name: "MlirPassthroughOp") ⇒ Object 



2346
2347
2348
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2346

def self.mlir_passthrough_op(inputs, mlir_module: "", tinputs: nil, toutputs: nil, name: "MlirPassthroughOp")
  self.execute("MlirPassthroughOp", [inputs], mlir_module: mlir_module, Tinputs: tinputs, Toutputs: toutputs, name: name)
end

.mod(x, y, typeT: nil, name: "Mod") ⇒ Object 



2350
2351
2352
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2350

def self.mod(x, y, typeT: nil, name: "Mod")
  self.execute("Mod", [x, y], T: typeT, name: name)
end

.model_dataset(input_dataset, algorithm: 0, cpu_budget: 0, output_types: nil, output_shapes: nil, name: "ModelDataset") ⇒ Object 



2354
2355
2356
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2354

def self.model_dataset(input_dataset, algorithm: 0, cpu_budget: 0, output_types: nil, output_shapes: nil, name: "ModelDataset")
  self.execute("ModelDataset", [input_dataset], algorithm: algorithm, cpu_budget: cpu_budget, output_types: output_types, output_shapes: output_shapes, name: name)
end

.mul(x, y, typeT: nil, name: "Mul") ⇒ Object 



2358
2359
2360
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2358

def self.mul(x, y, typeT: nil, name: "Mul")
  self.execute("Mul", [x, y], T: typeT, name: name)
end

.mul_no_nan(x, y, typeT: nil, name: "MulNoNan") ⇒ Object 



2362
2363
2364
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2362

def self.mul_no_nan(x, y, typeT: nil, name: "MulNoNan")
  self.execute("MulNoNan", [x, y], T: typeT, name: name)
end

.multi_device_iterator(devices: nil, shared_name: "", container: "", output_types: nil, output_shapes: nil, name: "MultiDeviceIterator") ⇒ Object 



2366
2367
2368
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2366

def self.multi_device_iterator(devices: nil, shared_name: "", container: "", output_types: nil, output_shapes: nil, name: "MultiDeviceIterator")
  self.execute("MultiDeviceIterator", [], devices: devices, shared_name: shared_name, container: container, output_types: output_types, output_shapes: output_shapes, name: name)
end

.multi_device_iterator_from_string_handle(string_handle, output_types: [], output_shapes: [], name: "MultiDeviceIteratorFromStringHandle") ⇒ Object 



2370
2371
2372
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2370

def self.multi_device_iterator_from_string_handle(string_handle, output_types: [], output_shapes: [], name: "MultiDeviceIteratorFromStringHandle")
  self.execute("MultiDeviceIteratorFromStringHandle", [string_handle], output_types: output_types, output_shapes: output_shapes, name: name)
end

.multi_device_iterator_get_next_from_shard(multi_device_iterator, shard_num, incarnation_id, output_types: nil, output_shapes: nil, name: "MultiDeviceIteratorGetNextFromShard") ⇒ Object 



2374
2375
2376
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2374

def self.multi_device_iterator_get_next_from_shard(multi_device_iterator, shard_num, incarnation_id, output_types: nil, output_shapes: nil, name: "MultiDeviceIteratorGetNextFromShard")
  self.execute("MultiDeviceIteratorGetNextFromShard", [multi_device_iterator, shard_num, incarnation_id], output_types: output_types, output_shapes: output_shapes, name: name)
end

.multi_device_iterator_init(dataset, multi_device_iterator, max_buffer_size, name: "MultiDeviceIteratorInit") ⇒ Object 



2378
2379
2380
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2378

def self.multi_device_iterator_init(dataset, multi_device_iterator, max_buffer_size, name: "MultiDeviceIteratorInit")
  self.execute("MultiDeviceIteratorInit", [dataset, multi_device_iterator, max_buffer_size], name: name)
end

.multi_device_iterator_to_string_handle(multi_device_iterator, name: "MultiDeviceIteratorToStringHandle") ⇒ Object 



2382
2383
2384
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2382

def self.multi_device_iterator_to_string_handle(multi_device_iterator, name: "MultiDeviceIteratorToStringHandle")
  self.execute("MultiDeviceIteratorToStringHandle", [multi_device_iterator], name: name)
end

.multinomial(logits, num_samples, seed: 0, seed2: 0, typeT: nil, output_dtype: :int64, name: "Multinomial") ⇒ Object 



2386
2387
2388
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2386

def self.multinomial(logits, num_samples, seed: 0, seed2: 0, typeT: nil, output_dtype: :int64, name: "Multinomial")
  self.execute("Multinomial", [logits, num_samples], seed: seed, seed2: seed2, T: typeT, output_dtype: output_dtype, name: name)
end

.mutable_dense_hash_table(empty_key, container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], initial_num_buckets: 131072, max_load_factor: 0.800000011920929, name: "MutableDenseHashTable") ⇒ Object 



2390
2391
2392
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2390

def self.mutable_dense_hash_table(empty_key, container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], initial_num_buckets: 131072, max_load_factor: 0.800000011920929, name: "MutableDenseHashTable")
  self.execute("MutableDenseHashTable", [empty_key], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, value_shape: value_shape, initial_num_buckets: initial_num_buckets, max_load_factor: max_load_factor, name: name)
end

.mutable_dense_hash_table_v2(empty_key, deleted_key, container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], initial_num_buckets: 131072, max_load_factor: 0.800000011920929, name: "MutableDenseHashTableV2") ⇒ Object 



2394
2395
2396
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2394

def self.mutable_dense_hash_table_v2(empty_key, deleted_key, container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], initial_num_buckets: 131072, max_load_factor: 0.800000011920929, name: "MutableDenseHashTableV2")
  self.execute("MutableDenseHashTableV2", [empty_key, deleted_key], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, value_shape: value_shape, initial_num_buckets: initial_num_buckets, max_load_factor: max_load_factor, name: name)
end

.mutable_hash_table(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "MutableHashTable") ⇒ Object 



2398
2399
2400
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2398

def self.mutable_hash_table(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "MutableHashTable")
  self.execute("MutableHashTable", [], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, name: name)
end

.mutable_hash_table_of_tensors(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], name: "MutableHashTableOfTensors") ⇒ Object 



2402
2403
2404
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2402

def self.mutable_hash_table_of_tensors(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], name: "MutableHashTableOfTensors")
  self.execute("MutableHashTableOfTensors", [], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, value_shape: value_shape, name: name)
end

.mutable_hash_table_of_tensors_v2(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], name: "MutableHashTableOfTensorsV2") ⇒ Object 



2406
2407
2408
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2406

def self.mutable_hash_table_of_tensors_v2(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, value_shape: [], name: "MutableHashTableOfTensorsV2")
  self.execute("MutableHashTableOfTensorsV2", [], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, value_shape: value_shape, name: name)
end

.mutable_hash_table_v2(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "MutableHashTableV2") ⇒ Object 



2410
2411
2412
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2410

def self.mutable_hash_table_v2(container: "", shared_name: "", use_node_name_sharing: false, key_dtype: nil, value_dtype: nil, name: "MutableHashTableV2")
  self.execute("MutableHashTableV2", [], container: container, shared_name: shared_name, use_node_name_sharing: use_node_name_sharing, key_dtype: key_dtype, value_dtype: value_dtype, name: name)
end

.mutex_lock(mutex, name: "MutexLock") ⇒ Object 



2414
2415
2416
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2414

def self.mutex_lock(mutex, name: "MutexLock")
  self.execute("MutexLock", [mutex], name: name)
end

.mutex_v2(container: "", shared_name: "", name: "MutexV2") ⇒ Object 



2418
2419
2420
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2418

def self.mutex_v2(container: "", shared_name: "", name: "MutexV2")
  self.execute("MutexV2", [], container: container, shared_name: shared_name, name: name)
end

.nccl_all_reduce(input, reduction: nil, typeT: nil, num_devices: nil, shared_name: "", name: "NcclAllReduce") ⇒ Object 



2422
2423
2424
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2422

def self.nccl_all_reduce(input, reduction: nil, typeT: nil, num_devices: nil, shared_name: "", name: "NcclAllReduce")
  self.execute("NcclAllReduce", [input], reduction: reduction, T: typeT, num_devices: num_devices, shared_name: shared_name, name: name)
end

.nccl_broadcast(input, typeT: nil, shape: nil, name: "NcclBroadcast") ⇒ Object 



2426
2427
2428
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2426

def self.nccl_broadcast(input, typeT: nil, shape: nil, name: "NcclBroadcast")
  self.execute("NcclBroadcast", [input], T: typeT, shape: shape, name: name)
end

.nccl_reduce(input, reduction: nil, typeT: nil, num_devices: nil, name: "NcclReduce") ⇒ Object 



2430
2431
2432
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2430

def self.nccl_reduce(input, reduction: nil, typeT: nil, num_devices: nil, name: "NcclReduce")
  self.execute("NcclReduce", [input], reduction: reduction, T: typeT, num_devices: num_devices, name: name)
end

.ndtri(x, typeT: nil, name: "Ndtri") ⇒ Object 



2434
2435
2436
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2434

def self.ndtri(x, typeT: nil, name: "Ndtri")
  self.execute("Ndtri", [x], T: typeT, name: name)
end

.nearest_neighbors(points, centers, k, name: "NearestNeighbors") ⇒ Object 



2438
2439
2440
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2438

def self.nearest_neighbors(points, centers, k, name: "NearestNeighbors")
  self.execute("NearestNeighbors", [points, centers, k], name: name)
end

.neg(x, typeT: nil, name: "Neg") ⇒ Object 



2442
2443
2444
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2442

def self.neg(x, typeT: nil, name: "Neg")
  self.execute("Neg", [x], T: typeT, name: name)
end

.neg_train(w_in, w_out, examples, labels, lr, vocab_count: nil, num_negative_samples: nil, name: "NegTrain") ⇒ Object 



2446
2447
2448
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2446

def self.neg_train(w_in, w_out, examples, labels, lr, vocab_count: nil, num_negative_samples: nil, name: "NegTrain")
  self.execute("NegTrain", [w_in, w_out, examples, labels, lr], vocab_count: vocab_count, num_negative_samples: num_negative_samples, name: name)
end

.next_after(x1, x2, typeT: :float, name: "NextAfter") ⇒ Object 



2450
2451
2452
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2450

def self.next_after(x1, x2, typeT: :float, name: "NextAfter")
  self.execute("NextAfter", [x1, x2], T: typeT, name: name)
end

.next_iteration(data, typeT: nil, name: "NextIteration") ⇒ Object 



2454
2455
2456
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2454

def self.next_iteration(data, typeT: nil, name: "NextIteration")
  self.execute("NextIteration", [data], T: typeT, name: name)
end

.no_op(name: "NoOp") ⇒ Object 



2458
2459
2460
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2458

def self.no_op(name: "NoOp")
  self.execute("NoOp", [], name: name)
end

.non_deterministic_ints(shape, dtype: :int64, shape_dtype: :int64, name: "NonDeterministicInts") ⇒ Object 



2462
2463
2464
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2462

def self.non_deterministic_ints(shape, dtype: :int64, shape_dtype: :int64, name: "NonDeterministicInts")
  self.execute("NonDeterministicInts", [shape], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.non_max_suppression(boxes, scores, max_output_size, iou_threshold: 0.5, name: "NonMaxSuppression") ⇒ Object 



2466
2467
2468
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2466

def self.non_max_suppression(boxes, scores, max_output_size, iou_threshold: 0.5, name: "NonMaxSuppression")
  self.execute("NonMaxSuppression", [boxes, scores, max_output_size], iou_threshold: iou_threshold, name: name)
end

.non_max_suppression_v2(boxes, scores, max_output_size, iou_threshold, typeT: :float, t_threshold: :float, name: "NonMaxSuppressionV2") ⇒ Object 



2470
2471
2472
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2470

def self.non_max_suppression_v2(boxes, scores, max_output_size, iou_threshold, typeT: :float, t_threshold: :float, name: "NonMaxSuppressionV2")
  self.execute("NonMaxSuppressionV2", [boxes, scores, max_output_size, iou_threshold], T: typeT, T_threshold: t_threshold, name: name)
end

.non_max_suppression_v3(boxes, scores, max_output_size, iou_threshold, score_threshold, typeT: :float, t_threshold: :float, name: "NonMaxSuppressionV3") ⇒ Object 



2474
2475
2476
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2474

def self.non_max_suppression_v3(boxes, scores, max_output_size, iou_threshold, score_threshold, typeT: :float, t_threshold: :float, name: "NonMaxSuppressionV3")
  self.execute("NonMaxSuppressionV3", [boxes, scores, max_output_size, iou_threshold, score_threshold], T: typeT, T_threshold: t_threshold, name: name)
end

.non_max_suppression_v4(boxes, scores, max_output_size, iou_threshold, score_threshold, typeT: :float, t_threshold: :float, pad_to_max_output_size: false, name: "NonMaxSuppressionV4") ⇒ Object 



2478
2479
2480
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2478

def self.non_max_suppression_v4(boxes, scores, max_output_size, iou_threshold, score_threshold, typeT: :float, t_threshold: :float, pad_to_max_output_size: false, name: "NonMaxSuppressionV4")
  self.execute("NonMaxSuppressionV4", [boxes, scores, max_output_size, iou_threshold, score_threshold], T: typeT, T_threshold: t_threshold, pad_to_max_output_size: pad_to_max_output_size, name: name)
end

.non_max_suppression_v5(boxes, scores, max_output_size, iou_threshold, score_threshold, soft_nms_sigma, typeT: :float, pad_to_max_output_size: false, name: "NonMaxSuppressionV5") ⇒ Object 



2482
2483
2484
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2482

def self.non_max_suppression_v5(boxes, scores, max_output_size, iou_threshold, score_threshold, soft_nms_sigma, typeT: :float, pad_to_max_output_size: false, name: "NonMaxSuppressionV5")
  self.execute("NonMaxSuppressionV5", [boxes, scores, max_output_size, iou_threshold, score_threshold, soft_nms_sigma], T: typeT, pad_to_max_output_size: pad_to_max_output_size, name: name)
end

.non_max_suppression_with_overlaps(overlaps, scores, max_output_size, overlap_threshold, score_threshold, name: "NonMaxSuppressionWithOverlaps") ⇒ Object 



2486
2487
2488
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2486

def self.non_max_suppression_with_overlaps(overlaps, scores, max_output_size, overlap_threshold, score_threshold, name: "NonMaxSuppressionWithOverlaps")
  self.execute("NonMaxSuppressionWithOverlaps", [overlaps, scores, max_output_size, overlap_threshold, score_threshold], name: name)
end

.non_serializable_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "NonSerializableDataset") ⇒ Object 



2490
2491
2492
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2490

def self.non_serializable_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "NonSerializableDataset")
  self.execute("NonSerializableDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.not_equal(x, y, typeT: nil, incompatible_shape_error: true, name: "NotEqual") ⇒ Object 



2494
2495
2496
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2494

def self.not_equal(x, y, typeT: nil, incompatible_shape_error: true, name: "NotEqual")
  self.execute("NotEqual", [x, y], T: typeT, incompatible_shape_error: incompatible_shape_error, name: name)
end

.nth_element(input, n, reverse: false, typeT: nil, name: "NthElement") ⇒ Object 



2498
2499
2500
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2498

def self.nth_element(input, n, reverse: false, typeT: nil, name: "NthElement")
  self.execute("NthElement", [input, n], reverse: reverse, T: typeT, name: name)
end

.one_hot(indices, depth, on_value, off_value, axis: -1,, typeT: nil, ti: :int64, name: "OneHot") ⇒ Object 



2502
2503
2504
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2502

def self.one_hot(indices, depth, on_value, off_value, axis: -1, typeT: nil, ti: :int64, name: "OneHot")
  self.execute("OneHot", [indices, depth, on_value, off_value], axis: axis, T: typeT, TI: ti, name: name)
end

.one_shot_iterator(dataset_factory: nil, output_types: nil, output_shapes: nil, container: "", shared_name: "", name: "OneShotIterator") ⇒ Object 



2506
2507
2508
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2506

def self.one_shot_iterator(dataset_factory: nil, output_types: nil, output_shapes: nil, container: "", shared_name: "", name: "OneShotIterator")
  self.execute("OneShotIterator", [], dataset_factory: dataset_factory, output_types: output_types, output_shapes: output_shapes, container: container, shared_name: shared_name, name: name)
end

.ones_like(x, typeT: nil, name: "OnesLike") ⇒ Object 



2510
2511
2512
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2510

def self.ones_like(x, typeT: nil, name: "OnesLike")
  self.execute("OnesLike", [x], T: typeT, name: name)
end

.optimize_dataset(input_dataset, optimizations, output_types: nil, output_shapes: nil, optimization_configs: [], name: "OptimizeDataset") ⇒ Object 



2514
2515
2516
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2514

def self.optimize_dataset(input_dataset, optimizations, output_types: nil, output_shapes: nil, optimization_configs: [], name: "OptimizeDataset")
  self.execute("OptimizeDataset", [input_dataset, optimizations], output_types: output_types, output_shapes: output_shapes, optimization_configs: optimization_configs, name: name)
end

.optional_from_value(components, toutput_types: nil, name: "OptionalFromValue") ⇒ Object 



2518
2519
2520
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2518

def self.optional_from_value(components, toutput_types: nil, name: "OptionalFromValue")
  self.execute("OptionalFromValue", [components], Toutput_types: toutput_types, name: name)
end

.optional_get_value(optional, output_types: nil, output_shapes: nil, name: "OptionalGetValue") ⇒ Object 



2522
2523
2524
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2522

def self.optional_get_value(optional, output_types: nil, output_shapes: nil, name: "OptionalGetValue")
  self.execute("OptionalGetValue", [optional], output_types: output_types, output_shapes: output_shapes, name: name)
end

.optional_has_value(optional, name: "OptionalHasValue") ⇒ Object 



2526
2527
2528
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2526

def self.optional_has_value(optional, name: "OptionalHasValue")
  self.execute("OptionalHasValue", [optional], name: name)
end

.optional_none(name: "OptionalNone") ⇒ Object 



2530
2531
2532
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2530

def self.optional_none(name: "OptionalNone")
  self.execute("OptionalNone", [], name: name)
end

.ordered_map_clear(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapClear") ⇒ Object 



2534
2535
2536
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2534

def self.ordered_map_clear(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapClear")
  self.execute("OrderedMapClear", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.ordered_map_incomplete_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapIncompleteSize") ⇒ Object 



2538
2539
2540
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2538

def self.ordered_map_incomplete_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapIncompleteSize")
  self.execute("OrderedMapIncompleteSize", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.ordered_map_peek(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapPeek") ⇒ Object 



2542
2543
2544
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2542

def self.ordered_map_peek(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapPeek")
  self.execute("OrderedMapPeek", [key, indices], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.ordered_map_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapSize") ⇒ Object 



2546
2547
2548
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2546

def self.ordered_map_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapSize")
  self.execute("OrderedMapSize", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.ordered_map_stage(key, indices, values, capacity: 0, memory_limit: 0, dtypes: nil, fake_dtypes: nil, container: "", shared_name: "", name: "OrderedMapStage") ⇒ Object 



2550
2551
2552
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2550

def self.ordered_map_stage(key, indices, values, capacity: 0, memory_limit: 0, dtypes: nil, fake_dtypes: nil, container: "", shared_name: "", name: "OrderedMapStage")
  self.execute("OrderedMapStage", [key, indices, values], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, fake_dtypes: fake_dtypes, container: container, shared_name: shared_name, name: name)
end

.ordered_map_unstage(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapUnstage") ⇒ Object 



2554
2555
2556
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2554

def self.ordered_map_unstage(key, indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapUnstage")
  self.execute("OrderedMapUnstage", [key, indices], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.ordered_map_unstage_no_key(indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapUnstageNoKey") ⇒ Object 



2558
2559
2560
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2558

def self.ordered_map_unstage_no_key(indices, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "OrderedMapUnstageNoKey")
  self.execute("OrderedMapUnstageNoKey", [indices], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.outfeed_dequeue(dtype: nil, shape: nil, device_ordinal: -1,, name: "OutfeedDequeue") ⇒ Object 



2562
2563
2564
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2562

def self.outfeed_dequeue(dtype: nil, shape: nil, device_ordinal: -1, name: "OutfeedDequeue")
  self.execute("OutfeedDequeue", [], dtype: dtype, shape: shape, device_ordinal: device_ordinal, name: name)
end

.outfeed_dequeue_tuple(dtypes: nil, shapes: nil, device_ordinal: -1,, name: "OutfeedDequeueTuple") ⇒ Object 



2566
2567
2568
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2566

def self.outfeed_dequeue_tuple(dtypes: nil, shapes: nil, device_ordinal: -1, name: "OutfeedDequeueTuple")
  self.execute("OutfeedDequeueTuple", [], dtypes: dtypes, shapes: shapes, device_ordinal: device_ordinal, name: name)
end

.outfeed_enqueue(input, dtype: nil, name: "OutfeedEnqueue") ⇒ Object 



2570
2571
2572
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2570

def self.outfeed_enqueue(input, dtype: nil, name: "OutfeedEnqueue")
  self.execute("OutfeedEnqueue", [input], dtype: dtype, name: name)
end

.outfeed_enqueue_tuple(inputs, dtypes: nil, name: "OutfeedEnqueueTuple") ⇒ Object 



2574
2575
2576
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2574

def self.outfeed_enqueue_tuple(inputs, dtypes: nil, name: "OutfeedEnqueueTuple")
  self.execute("OutfeedEnqueueTuple", [inputs], dtypes: dtypes, name: name)
end

.pack(values, n: nil, typeT: nil, axis: 0, name: "Pack") ⇒ Object 



2578
2579
2580
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2578

def self.pack(values, n: nil, typeT: nil, axis: 0, name: "Pack")
  self.execute("Pack", [values], N: n, T: typeT, axis: axis, name: name)
end

.pad(input, paddings, typeT: nil, tpaddings: :int32, name: "Pad") ⇒ Object 



2582
2583
2584
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2582

def self.pad(input, paddings, typeT: nil, tpaddings: :int32, name: "Pad")
  self.execute("Pad", [input, paddings], T: typeT, Tpaddings: tpaddings, name: name)
end

.pad_v2(input, paddings, constant_values, typeT: nil, tpaddings: :int32, name: "PadV2") ⇒ Object 



2586
2587
2588
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2586

def self.pad_v2(input, paddings, constant_values, typeT: nil, tpaddings: :int32, name: "PadV2")
  self.execute("PadV2", [input, paddings, constant_values], T: typeT, Tpaddings: tpaddings, name: name)
end

.padded_batch_dataset(input_dataset, batch_size, padded_shapes, padding_values, toutput_types: nil, output_shapes: nil, n: nil, name: "PaddedBatchDataset") ⇒ Object 



2590
2591
2592
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2590

def self.padded_batch_dataset(input_dataset, batch_size, padded_shapes, padding_values, toutput_types: nil, output_shapes: nil, n: nil, name: "PaddedBatchDataset")
  self.execute("PaddedBatchDataset", [input_dataset, batch_size, padded_shapes, padding_values], Toutput_types: toutput_types, output_shapes: output_shapes, N: n, name: name)
end

.padded_batch_dataset_v2(input_dataset, batch_size, padded_shapes, padding_values, drop_remainder, parallel_copy: false, toutput_types: nil, output_shapes: nil, n: nil, name: "PaddedBatchDatasetV2") ⇒ Object 



2594
2595
2596
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2594

def self.padded_batch_dataset_v2(input_dataset, batch_size, padded_shapes, padding_values, drop_remainder, parallel_copy: false, toutput_types: nil, output_shapes: nil, n: nil, name: "PaddedBatchDatasetV2")
  self.execute("PaddedBatchDatasetV2", [input_dataset, batch_size, padded_shapes, padding_values, drop_remainder], parallel_copy: parallel_copy, Toutput_types: toutput_types, output_shapes: output_shapes, N: n, name: name)
end

.padding_fifo_queue(component_types: nil, shapes: [], capacity: -1,, container: "", shared_name: "", name: "PaddingFIFOQueue") ⇒ Object 



2598
2599
2600
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2598

def self.padding_fifo_queue(component_types: nil, shapes: [], capacity: -1, container: "", shared_name: "", name: "PaddingFIFOQueue")
  self.execute("PaddingFIFOQueue", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.padding_fifo_queue_v2(component_types: nil, shapes: [], capacity: -1,, container: "", shared_name: "", name: "PaddingFIFOQueueV2") ⇒ Object 



2602
2603
2604
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2602

def self.padding_fifo_queue_v2(component_types: nil, shapes: [], capacity: -1, container: "", shared_name: "", name: "PaddingFIFOQueueV2")
  self.execute("PaddingFIFOQueueV2", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.parallel_concat(values, n: nil, typeT: nil, shape: nil, name: "ParallelConcat") ⇒ Object 



2606
2607
2608
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2606

def self.parallel_concat(values, n: nil, typeT: nil, shape: nil, name: "ParallelConcat")
  self.execute("ParallelConcat", [values], N: n, T: typeT, shape: shape, name: name)
end

.parallel_dynamic_stitch(indices, data, n: nil, typeT: nil, name: "ParallelDynamicStitch") ⇒ Object 



2610
2611
2612
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2610

def self.parallel_dynamic_stitch(indices, data, n: nil, typeT: nil, name: "ParallelDynamicStitch")
  self.execute("ParallelDynamicStitch", [indices, data], N: n, T: typeT, name: name)
end

.parallel_interleave_dataset(input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "ParallelInterleaveDataset") ⇒ Object 



2614
2615
2616
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2614

def self.parallel_interleave_dataset(input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, f: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "ParallelInterleaveDataset")
  self.execute("ParallelInterleaveDataset", [input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.parallel_interleave_dataset_v2(input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls, f: nil, targuments: nil, output_types: nil, output_shapes: nil, sloppy: false, name: "ParallelInterleaveDatasetV2") ⇒ Object 



2618
2619
2620
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2618

def self.parallel_interleave_dataset_v2(input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls, f: nil, targuments: nil, output_types: nil, output_shapes: nil, sloppy: false, name: "ParallelInterleaveDatasetV2")
  self.execute("ParallelInterleaveDatasetV2", [input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, sloppy: sloppy, name: name)
end

.parallel_map_dataset(input_dataset, other_arguments, num_parallel_calls, f: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, sloppy: false, preserve_cardinality: false, name: "ParallelMapDataset") ⇒ Object 



2622
2623
2624
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2622

def self.parallel_map_dataset(input_dataset, other_arguments, num_parallel_calls, f: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, sloppy: false, preserve_cardinality: false, name: "ParallelMapDataset")
  self.execute("ParallelMapDataset", [input_dataset, other_arguments, num_parallel_calls], f: f, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, use_inter_op_parallelism: use_inter_op_parallelism, sloppy: sloppy, preserve_cardinality: preserve_cardinality, name: name)
end

.parameterized_truncated_normal(shape, means, stdevs, minvals, maxvals, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "ParameterizedTruncatedNormal") ⇒ Object 



2626
2627
2628
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2626

def self.parameterized_truncated_normal(shape, means, stdevs, minvals, maxvals, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "ParameterizedTruncatedNormal")
  self.execute("ParameterizedTruncatedNormal", [shape, means, stdevs, minvals, maxvals], seed: seed, seed2: seed2, dtype: dtype, T: typeT, name: name)
end

.parse_example(serialized, names, sparse_keys, dense_keys, dense_defaults, nsparse: nil, ndense: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, name: "ParseExample") ⇒ Object 



2630
2631
2632
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2630

def self.parse_example(serialized, names, sparse_keys, dense_keys, dense_defaults, nsparse: nil, ndense: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, name: "ParseExample")
  self.execute("ParseExample", [serialized, names, sparse_keys, dense_keys, dense_defaults], Nsparse: nsparse, Ndense: ndense, sparse_types: sparse_types, Tdense: tdense, dense_shapes: dense_shapes, name: name)
end

.parse_example_dataset(input_dataset, num_parallel_calls, dense_defaults, sparse_keys: nil, dense_keys: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, output_types: nil, output_shapes: nil, sloppy: false, ragged_keys: [], ragged_value_types: [], ragged_split_types: [], name: "ParseExampleDataset") ⇒ Object 



2634
2635
2636
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2634

def self.parse_example_dataset(input_dataset, num_parallel_calls, dense_defaults, sparse_keys: nil, dense_keys: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, output_types: nil, output_shapes: nil, sloppy: false, ragged_keys: [], ragged_value_types: [], ragged_split_types: [], name: "ParseExampleDataset")
  self.execute("ParseExampleDataset", [input_dataset, num_parallel_calls, dense_defaults], sparse_keys: sparse_keys, dense_keys: dense_keys, sparse_types: sparse_types, Tdense: tdense, dense_shapes: dense_shapes, output_types: output_types, output_shapes: output_shapes, sloppy: sloppy, ragged_keys: ragged_keys, ragged_value_types: ragged_value_types, ragged_split_types: ragged_split_types, name: name)
end

.parse_example_v2(serialized, names, sparse_keys, dense_keys, ragged_keys, dense_defaults, tdense: nil, num_sparse: nil, sparse_types: nil, ragged_value_types: nil, ragged_split_types: nil, dense_shapes: nil, name: "ParseExampleV2") ⇒ Object 



2638
2639
2640
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2638

def self.parse_example_v2(serialized, names, sparse_keys, dense_keys, ragged_keys, dense_defaults, tdense: nil, num_sparse: nil, sparse_types: nil, ragged_value_types: nil, ragged_split_types: nil, dense_shapes: nil, name: "ParseExampleV2")
  self.execute("ParseExampleV2", [serialized, names, sparse_keys, dense_keys, ragged_keys, dense_defaults], Tdense: tdense, num_sparse: num_sparse, sparse_types: sparse_types, ragged_value_types: ragged_value_types, ragged_split_types: ragged_split_types, dense_shapes: dense_shapes, name: name)
end

.parse_sequence_example(serialized, debug_name, context_dense_defaults, feature_list_dense_missing_assumed_empty: nil, context_sparse_keys: nil, context_dense_keys: nil, feature_list_sparse_keys: nil, feature_list_dense_keys: nil, ncontext_sparse: 0, ncontext_dense: 0, nfeature_list_sparse: 0, nfeature_list_dense: 0, context_sparse_types: [], tcontext_dense: [], feature_list_dense_types: [], context_dense_shapes: [], feature_list_sparse_types: [], feature_list_dense_shapes: [], name: "ParseSequenceExample") ⇒ Object 



2642
2643
2644
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2642

def self.parse_sequence_example(serialized, debug_name, context_dense_defaults, feature_list_dense_missing_assumed_empty: nil, context_sparse_keys: nil, context_dense_keys: nil, feature_list_sparse_keys: nil, feature_list_dense_keys: nil, ncontext_sparse: 0, ncontext_dense: 0, nfeature_list_sparse: 0, nfeature_list_dense: 0, context_sparse_types: [], tcontext_dense: [], feature_list_dense_types: [], context_dense_shapes: [], feature_list_sparse_types: [], feature_list_dense_shapes: [], name: "ParseSequenceExample")
  self.execute("ParseSequenceExample", [serialized, debug_name, context_dense_defaults], feature_list_dense_missing_assumed_empty: feature_list_dense_missing_assumed_empty, context_sparse_keys: context_sparse_keys, context_dense_keys: context_dense_keys, feature_list_sparse_keys: feature_list_sparse_keys, feature_list_dense_keys: feature_list_dense_keys, Ncontext_sparse: ncontext_sparse, Ncontext_dense: ncontext_dense, Nfeature_list_sparse: nfeature_list_sparse, Nfeature_list_dense: nfeature_list_dense, context_sparse_types: context_sparse_types, Tcontext_dense: tcontext_dense, feature_list_dense_types: feature_list_dense_types, context_dense_shapes: context_dense_shapes, feature_list_sparse_types: feature_list_sparse_types, feature_list_dense_shapes: feature_list_dense_shapes, name: name)
end

.parse_sequence_example_v2(serialized, debug_name, context_sparse_keys, context_dense_keys, context_ragged_keys, feature_list_sparse_keys, feature_list_dense_keys, feature_list_ragged_keys, feature_list_dense_missing_assumed_empty, context_dense_defaults, ncontext_sparse: 0, tcontext_dense: [], context_sparse_types: [], context_ragged_value_types: [], context_ragged_split_types: [], context_dense_shapes: [], nfeature_list_sparse: 0, nfeature_list_dense: 0, feature_list_dense_types: [], feature_list_sparse_types: [], feature_list_ragged_value_types: [], feature_list_ragged_split_types: [], feature_list_dense_shapes: [], name: "ParseSequenceExampleV2") ⇒ Object 



2646
2647
2648
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2646

def self.parse_sequence_example_v2(serialized, debug_name, context_sparse_keys, context_dense_keys, context_ragged_keys, feature_list_sparse_keys, feature_list_dense_keys, feature_list_ragged_keys, feature_list_dense_missing_assumed_empty, context_dense_defaults, ncontext_sparse: 0, tcontext_dense: [], context_sparse_types: [], context_ragged_value_types: [], context_ragged_split_types: [], context_dense_shapes: [], nfeature_list_sparse: 0, nfeature_list_dense: 0, feature_list_dense_types: [], feature_list_sparse_types: [], feature_list_ragged_value_types: [], feature_list_ragged_split_types: [], feature_list_dense_shapes: [], name: "ParseSequenceExampleV2")
  self.execute("ParseSequenceExampleV2", [serialized, debug_name, context_sparse_keys, context_dense_keys, context_ragged_keys, feature_list_sparse_keys, feature_list_dense_keys, feature_list_ragged_keys, feature_list_dense_missing_assumed_empty, context_dense_defaults], Ncontext_sparse: ncontext_sparse, Tcontext_dense: tcontext_dense, context_sparse_types: context_sparse_types, context_ragged_value_types: context_ragged_value_types, context_ragged_split_types: context_ragged_split_types, context_dense_shapes: context_dense_shapes, Nfeature_list_sparse: nfeature_list_sparse, Nfeature_list_dense: nfeature_list_dense, feature_list_dense_types: feature_list_dense_types, feature_list_sparse_types: feature_list_sparse_types, feature_list_ragged_value_types: feature_list_ragged_value_types, feature_list_ragged_split_types: feature_list_ragged_split_types, feature_list_dense_shapes: feature_list_dense_shapes, name: name)
end

.parse_single_example(serialized, dense_defaults, num_sparse: nil, sparse_keys: nil, dense_keys: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, name: "ParseSingleExample") ⇒ Object 



2650
2651
2652
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2650

def self.parse_single_example(serialized, dense_defaults, num_sparse: nil, sparse_keys: nil, dense_keys: nil, sparse_types: nil, tdense: nil, dense_shapes: nil, name: "ParseSingleExample")
  self.execute("ParseSingleExample", [serialized, dense_defaults], num_sparse: num_sparse, sparse_keys: sparse_keys, dense_keys: dense_keys, sparse_types: sparse_types, Tdense: tdense, dense_shapes: dense_shapes, name: name)
end

.parse_single_sequence_example(serialized, feature_list_dense_missing_assumed_empty, context_sparse_keys, context_dense_keys, feature_list_sparse_keys, feature_list_dense_keys, context_dense_defaults, debug_name, ncontext_sparse: 0, ncontext_dense: 0, nfeature_list_sparse: 0, nfeature_list_dense: 0, context_sparse_types: [], tcontext_dense: [], feature_list_dense_types: [], context_dense_shapes: [], feature_list_sparse_types: [], feature_list_dense_shapes: [], name: "ParseSingleSequenceExample") ⇒ Object 



2654
2655
2656
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2654

def self.parse_single_sequence_example(serialized, feature_list_dense_missing_assumed_empty, context_sparse_keys, context_dense_keys, feature_list_sparse_keys, feature_list_dense_keys, context_dense_defaults, debug_name, ncontext_sparse: 0, ncontext_dense: 0, nfeature_list_sparse: 0, nfeature_list_dense: 0, context_sparse_types: [], tcontext_dense: [], feature_list_dense_types: [], context_dense_shapes: [], feature_list_sparse_types: [], feature_list_dense_shapes: [], name: "ParseSingleSequenceExample")
  self.execute("ParseSingleSequenceExample", [serialized, feature_list_dense_missing_assumed_empty, context_sparse_keys, context_dense_keys, feature_list_sparse_keys, feature_list_dense_keys, context_dense_defaults, debug_name], Ncontext_sparse: ncontext_sparse, Ncontext_dense: ncontext_dense, Nfeature_list_sparse: nfeature_list_sparse, Nfeature_list_dense: nfeature_list_dense, context_sparse_types: context_sparse_types, Tcontext_dense: tcontext_dense, feature_list_dense_types: feature_list_dense_types, context_dense_shapes: context_dense_shapes, feature_list_sparse_types: feature_list_sparse_types, feature_list_dense_shapes: feature_list_dense_shapes, name: name)
end

.parse_tensor(serialized, out_type: nil, name: "ParseTensor") ⇒ Object 



2658
2659
2660
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2658

def self.parse_tensor(serialized, out_type: nil, name: "ParseTensor")
  self.execute("ParseTensor", [serialized], out_type: out_type, name: name)
end

.partitioned_call(args, tin: nil, tout: nil, f: nil, config: "", config_proto: "", executor_type: "", name: "PartitionedCall") ⇒ Object 



2662
2663
2664
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2662

def self.partitioned_call(args, tin: nil, tout: nil, f: nil, config: "", config_proto: "", executor_type: "", name: "PartitionedCall")
  self.execute("PartitionedCall", [args], Tin: tin, Tout: tout, f: f, config: config, config_proto: config_proto, executor_type: executor_type, name: name)
end

.placeholder(dtype: nil, shape: [], name: "Placeholder") ⇒ Object 



2666
2667
2668
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2666

def self.placeholder(dtype: nil, shape: [], name: "Placeholder")
  self.execute("Placeholder", [], dtype: dtype, shape: shape, name: name)
end

.placeholder_v2(dtype: nil, shape: nil, name: "PlaceholderV2") ⇒ Object 



2670
2671
2672
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2670

def self.placeholder_v2(dtype: nil, shape: nil, name: "PlaceholderV2")
  self.execute("PlaceholderV2", [], dtype: dtype, shape: shape, name: name)
end

.placeholder_with_default(input, dtype: nil, shape: nil, name: "PlaceholderWithDefault") ⇒ Object 



2674
2675
2676
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2674

def self.placeholder_with_default(input, dtype: nil, shape: nil, name: "PlaceholderWithDefault")
  self.execute("PlaceholderWithDefault", [input], dtype: dtype, shape: shape, name: name)
end

.polygamma(a, x, typeT: nil, name: "Polygamma") ⇒ Object 



2678
2679
2680
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2678

def self.polygamma(a, x, typeT: nil, name: "Polygamma")
  self.execute("Polygamma", [a, x], T: typeT, name: name)
end

.population_count(x, typeT: nil, name: "PopulationCount") ⇒ Object 



2682
2683
2684
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2682

def self.population_count(x, typeT: nil, name: "PopulationCount")
  self.execute("PopulationCount", [x], T: typeT, name: name)
end

.pow(x, y, typeT: nil, name: "Pow") ⇒ Object 



2686
2687
2688
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2686

def self.pow(x, y, typeT: nil, name: "Pow")
  self.execute("Pow", [x, y], T: typeT, name: name)
end

.prefetch_dataset(input_dataset, buffer_size, output_types: nil, output_shapes: nil, slack_period: 0, legacy_autotune: true, name: "PrefetchDataset") ⇒ Object 



2690
2691
2692
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2690

def self.prefetch_dataset(input_dataset, buffer_size, output_types: nil, output_shapes: nil, slack_period: 0, legacy_autotune: true, name: "PrefetchDataset")
  self.execute("PrefetchDataset", [input_dataset, buffer_size], output_types: output_types, output_shapes: output_shapes, slack_period: slack_period, legacy_autotune: legacy_autotune, name: name)
end

.prelinearize(input, dtype: nil, shape: [], layout: [], name: "Prelinearize") ⇒ Object 



2694
2695
2696
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2694

def self.prelinearize(input, dtype: nil, shape: [], layout: [], name: "Prelinearize")
  self.execute("Prelinearize", [input], dtype: dtype, shape: shape, layout: layout, name: name)
end

.prelinearize_tuple(inputs, dtypes: nil, shapes: nil, layouts: [], name: "PrelinearizeTuple") ⇒ Object 



2698
2699
2700
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2698

def self.prelinearize_tuple(inputs, dtypes: nil, shapes: nil, layouts: [], name: "PrelinearizeTuple")
  self.execute("PrelinearizeTuple", [inputs], dtypes: dtypes, shapes: shapes, layouts: layouts, name: name)
end

.prevent_gradient(input, typeT: nil, message: "", name: "PreventGradient") ⇒ Object 



2702
2703
2704
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2702

def self.prevent_gradient(input, typeT: nil, message: "", name: "PreventGradient")
  self.execute("PreventGradient", [input], T: typeT, message: message, name: name)
end

.print(input, data, typeT: nil, u: nil, message: "", first_n: -1,, summarize: 3, name: "Print") ⇒ Object 



2706
2707
2708
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2706

def self.print(input, data, typeT: nil, u: nil, message: "", first_n: -1, summarize: 3, name: "Print")
  self.execute("Print", [input, data], T: typeT, U: u, message: message, first_n: first_n, summarize: summarize, name: name)
end

.print_v2(input, output_stream: "stderr", stop: " ", name: "PrintV2") ⇒ Object 



2710
2711
2712
2713
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2710

def self.print_v2(input, output_stream: "stderr", stop: "
", name: "PrintV2")
  self.execute("PrintV2", [input], output_stream: output_stream, end: stop, name: name)
end

.priority_queue(component_types: [], shapes: nil, capacity: -1,, container: "", shared_name: "", name: "PriorityQueue") ⇒ Object 



2715
2716
2717
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2715

def self.priority_queue(component_types: [], shapes: nil, capacity: -1, container: "", shared_name: "", name: "PriorityQueue")
  self.execute("PriorityQueue", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.priority_queue_v2(component_types: [], shapes: nil, capacity: -1,, container: "", shared_name: "", name: "PriorityQueueV2") ⇒ Object 



2719
2720
2721
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2719

def self.priority_queue_v2(component_types: [], shapes: nil, capacity: -1, container: "", shared_name: "", name: "PriorityQueueV2")
  self.execute("PriorityQueueV2", [], component_types: component_types, shapes: shapes, capacity: capacity, container: container, shared_name: shared_name, name: name)
end

.private_thread_pool_dataset(input_dataset, num_threads, output_types: nil, output_shapes: nil, name: "PrivateThreadPoolDataset") ⇒ Object 



2723
2724
2725
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2723

def self.private_thread_pool_dataset(input_dataset, num_threads, output_types: nil, output_shapes: nil, name: "PrivateThreadPoolDataset")
  self.execute("PrivateThreadPoolDataset", [input_dataset, num_threads], output_types: output_types, output_shapes: output_shapes, name: name)
end

.prod(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Prod") ⇒ Object 



2727
2728
2729
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2727

def self.prod(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Prod")
  self.execute("Prod", [input, reduction_indices], keep_dims: keep_dims, T: typeT, Tidx: tidx, name: name)
end

.py_func(input, token: "", tin: nil, tout: nil, name: "PyFunc") ⇒ Object 



2731
2732
2733
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2731

def self.py_func(input, token: "", tin: nil, tout: nil, name: "PyFunc")
  self.execute("PyFunc", [input], token: token, Tin: tin, Tout: tout, name: name)
end

.py_func_stateless(input, token: "", tin: nil, tout: nil, name: "PyFuncStateless") ⇒ Object 



2735
2736
2737
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2735

def self.py_func_stateless(input, token: "", tin: nil, tout: nil, name: "PyFuncStateless")
  self.execute("PyFuncStateless", [input], token: token, Tin: tin, Tout: tout, name: name)
end

.qr(input, full_matrices: false, typeT: nil, name: "Qr") ⇒ Object 



2739
2740
2741
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2739

def self.qr(input, full_matrices: false, typeT: nil, name: "Qr")
  self.execute("Qr", [input], full_matrices: full_matrices, T: typeT, name: name)
end

.quantize_and_dequantize(input, signed_input: true, num_bits: 8, range_given: false, input_min: 0.0, input_max: 0.0, typeT: nil, name: "QuantizeAndDequantize") ⇒ Object 



2743
2744
2745
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2743

def self.quantize_and_dequantize(input, signed_input: true, num_bits: 8, range_given: false, input_min: 0.0, input_max: 0.0, typeT: nil, name: "QuantizeAndDequantize")
  self.execute("QuantizeAndDequantize", [input], signed_input: signed_input, num_bits: num_bits, range_given: range_given, input_min: input_min, input_max: input_max, T: typeT, name: name)
end

.quantize_and_dequantize_v2(input, input_min, input_max, signed_input: true, num_bits: 8, range_given: false, typeT: nil, round_mode: "HALF_TO_EVEN", narrow_range: false, axis: -1,, name: "QuantizeAndDequantizeV2") ⇒ Object 



2747
2748
2749
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2747

def self.quantize_and_dequantize_v2(input, input_min, input_max, signed_input: true, num_bits: 8, range_given: false, typeT: nil, round_mode: "HALF_TO_EVEN", narrow_range: false, axis: -1, name: "QuantizeAndDequantizeV2")
  self.execute("QuantizeAndDequantizeV2", [input, input_min, input_max], signed_input: signed_input, num_bits: num_bits, range_given: range_given, T: typeT, round_mode: round_mode, narrow_range: narrow_range, axis: axis, name: name)
end

.quantize_and_dequantize_v3(input, input_min, input_max, num_bits, signed_input: true, range_given: true, typeT: nil, narrow_range: false, axis: -1,, name: "QuantizeAndDequantizeV3") ⇒ Object 



2751
2752
2753
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2751

def self.quantize_and_dequantize_v3(input, input_min, input_max, num_bits, signed_input: true, range_given: true, typeT: nil, narrow_range: false, axis: -1, name: "QuantizeAndDequantizeV3")
  self.execute("QuantizeAndDequantizeV3", [input, input_min, input_max, num_bits], signed_input: signed_input, range_given: range_given, T: typeT, narrow_range: narrow_range, axis: axis, name: name)
end

.quantize_down_and_shrink_range(input, input_min, input_max, tinput: nil, out_type: nil, name: "QuantizeDownAndShrinkRange") ⇒ Object 



2755
2756
2757
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2755

def self.quantize_down_and_shrink_range(input, input_min, input_max, tinput: nil, out_type: nil, name: "QuantizeDownAndShrinkRange")
  self.execute("QuantizeDownAndShrinkRange", [input, input_min, input_max], Tinput: tinput, out_type: out_type, name: name)
end

.quantize_v2(input, min_range, max_range, typeT: nil, mode: "MIN_COMBINED", round_mode: "HALF_AWAY_FROM_ZERO", narrow_range: false, axis: -1,, ensure_minimum_range: 0.009999999776482582, name: "QuantizeV2") ⇒ Object 



2759
2760
2761
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2759

def self.quantize_v2(input, min_range, max_range, typeT: nil, mode: "MIN_COMBINED", round_mode: "HALF_AWAY_FROM_ZERO", narrow_range: false, axis: -1, ensure_minimum_range: 0.009999999776482582, name: "QuantizeV2")
  self.execute("QuantizeV2", [input, min_range, max_range], T: typeT, mode: mode, round_mode: round_mode, narrow_range: narrow_range, axis: axis, ensure_minimum_range: ensure_minimum_range, name: name)
end

.quantized_add(x, y, min_x, max_x, min_y, max_y, t1: nil, t2: nil, toutput: :qint32, name: "QuantizedAdd") ⇒ Object 



2763
2764
2765
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2763

def self.quantized_add(x, y, min_x, max_x, min_y, max_y, t1: nil, t2: nil, toutput: :qint32, name: "QuantizedAdd")
  self.execute("QuantizedAdd", [x, y, min_x, max_x, min_y, max_y], T1: t1, T2: t2, Toutput: toutput, name: name)
end

.quantized_avg_pool(input, min_input, max_input, typeT: nil, ksize: nil, strides: nil, padding: nil, name: "QuantizedAvgPool") ⇒ Object 



2767
2768
2769
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2767

def self.quantized_avg_pool(input, min_input, max_input, typeT: nil, ksize: nil, strides: nil, padding: nil, name: "QuantizedAvgPool")
  self.execute("QuantizedAvgPool", [input, min_input, max_input], T: typeT, ksize: ksize, strides: strides, padding: padding, name: name)
end

.quantized_batch_norm_with_global_normalization(t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max, tinput: nil, out_type: nil, variance_epsilon: nil, scale_after_normalization: nil, name: "QuantizedBatchNormWithGlobalNormalization") ⇒ Object 



2771
2772
2773
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2771

def self.quantized_batch_norm_with_global_normalization(t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max, tinput: nil, out_type: nil, variance_epsilon: nil, scale_after_normalization: nil, name: "QuantizedBatchNormWithGlobalNormalization")
  self.execute("QuantizedBatchNormWithGlobalNormalization", [t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max], Tinput: tinput, out_type: out_type, variance_epsilon: variance_epsilon, scale_after_normalization: scale_after_normalization, name: name)
end

.quantized_bias_add(input, bias, min_input, max_input, min_bias, max_bias, t1: nil, t2: nil, out_type: nil, name: "QuantizedBiasAdd") ⇒ Object 



2775
2776
2777
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2775

def self.quantized_bias_add(input, bias, min_input, max_input, min_bias, max_bias, t1: nil, t2: nil, out_type: nil, name: "QuantizedBiasAdd")
  self.execute("QuantizedBiasAdd", [input, bias, min_input, max_input, min_bias, max_bias], T1: t1, T2: t2, out_type: out_type, name: name)
end

.quantized_concat(concat_dim, values, input_mins, input_maxes, n: nil, typeT: nil, name: "QuantizedConcat") ⇒ Object 



2779
2780
2781
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2779

def self.quantized_concat(concat_dim, values, input_mins, input_maxes, n: nil, typeT: nil, name: "QuantizedConcat")
  self.execute("QuantizedConcat", [concat_dim, values, input_mins, input_maxes], N: n, T: typeT, name: name)
end

.quantized_conv2_d(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedConv2D") ⇒ Object 



2783
2784
2785
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2783

def self.quantized_conv2_d(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedConv2D")
  self.execute("QuantizedConv2D", [input, filter, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, name: name)
end

.quantized_conv2_d_and_relu(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DAndRelu") ⇒ Object 



2787
2788
2789
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2787

def self.quantized_conv2_d_and_relu(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DAndRelu")
  self.execute("QuantizedConv2DAndRelu", [input, filter, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_and_relu_and_requantize(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DAndReluAndRequantize") ⇒ Object 



2791
2792
2793
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2791

def self.quantized_conv2_d_and_relu_and_requantize(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DAndReluAndRequantize")
  self.execute("QuantizedConv2DAndReluAndRequantize", [input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_and_requantize(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, out_type: :qint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DAndRequantize") ⇒ Object 



2795
2796
2797
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2795

def self.quantized_conv2_d_and_requantize(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, out_type: :qint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DAndRequantize")
  self.execute("QuantizedConv2DAndRequantize", [input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_per_channel(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedConv2DPerChannel") ⇒ Object 



2799
2800
2801
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2799

def self.quantized_conv2_d_per_channel(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedConv2DPerChannel")
  self.execute("QuantizedConv2DPerChannel", [input, filter, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, name: name)
end

.quantized_conv2_d_with_bias(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBias") ⇒ Object 



2803
2804
2805
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2803

def self.quantized_conv2_d_with_bias(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBias")
  self.execute("QuantizedConv2DWithBias", [input, filter, bias, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_with_bias_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasAndRelu") ⇒ Object 



2807
2808
2809
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2807

def self.quantized_conv2_d_with_bias_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasAndRelu")
  self.execute("QuantizedConv2DWithBiasAndRelu", [input, filter, bias, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_with_bias_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, tbias: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasAndReluAndRequantize") ⇒ Object 



2811
2812
2813
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2811

def self.quantized_conv2_d_with_bias_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, tbias: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasAndReluAndRequantize")
  self.execute("QuantizedConv2DWithBiasAndReluAndRequantize", [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output], Tinput: tinput, Tfilter: tfilter, Tbias: tbias, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_with_bias_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, tbias: nil, out_type: :qint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasAndRequantize") ⇒ Object 



2815
2816
2817
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2815

def self.quantized_conv2_d_with_bias_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, tbias: nil, out_type: :qint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasAndRequantize")
  self.execute("QuantizedConv2DWithBiasAndRequantize", [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output], Tinput: tinput, Tfilter: tfilter, Tbias: tbias, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_with_bias_signed_sum_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand, tinput: nil, tfilter: nil, tbias: nil, tsummand: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize") ⇒ Object 



2819
2820
2821
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2819

def self.quantized_conv2_d_with_bias_signed_sum_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand, tinput: nil, tfilter: nil, tbias: nil, tsummand: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize")
  self.execute("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand], Tinput: tinput, Tfilter: tfilter, Tbias: tbias, Tsummand: tsummand, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_with_bias_sum_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, summand, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasSumAndRelu") ⇒ Object 



2823
2824
2825
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2823

def self.quantized_conv2_d_with_bias_sum_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, summand, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasSumAndRelu")
  self.execute("QuantizedConv2DWithBiasSumAndRelu", [input, filter, bias, min_input, max_input, min_filter, max_filter, summand], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_conv2_d_with_bias_sum_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand, tinput: nil, tfilter: nil, tbias: nil, tsummand: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasSumAndReluAndRequantize") ⇒ Object 



2827
2828
2829
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2827

def self.quantized_conv2_d_with_bias_sum_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand, tinput: nil, tfilter: nil, tbias: nil, tsummand: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], padding_list: [], name: "QuantizedConv2DWithBiasSumAndReluAndRequantize")
  self.execute("QuantizedConv2DWithBiasSumAndReluAndRequantize", [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand], Tinput: tinput, Tfilter: tfilter, Tbias: tbias, Tsummand: tsummand, out_type: out_type, strides: strides, padding: padding, dilations: dilations, padding_list: padding_list, name: name)
end

.quantized_depthwise_conv2_d(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2D") ⇒ Object 



2831
2832
2833
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2831

def self.quantized_depthwise_conv2_d(input, filter, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2D")
  self.execute("QuantizedDepthwiseConv2D", [input, filter, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, name: name)
end

.quantized_depthwise_conv2_d_with_bias(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2DWithBias") ⇒ Object 



2835
2836
2837
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2835

def self.quantized_depthwise_conv2_d_with_bias(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2DWithBias")
  self.execute("QuantizedDepthwiseConv2DWithBias", [input, filter, bias, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, name: name)
end

.quantized_depthwise_conv2_d_with_bias_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2DWithBiasAndRelu") ⇒ Object 



2839
2840
2841
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2839

def self.quantized_depthwise_conv2_d_with_bias_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, tinput: nil, tfilter: nil, out_type: :qint32, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2DWithBiasAndRelu")
  self.execute("QuantizedDepthwiseConv2DWithBiasAndRelu", [input, filter, bias, min_input, max_input, min_filter, max_filter], Tinput: tinput, Tfilter: tfilter, out_type: out_type, strides: strides, padding: padding, dilations: dilations, name: name)
end

.quantized_depthwise_conv2_d_with_bias_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, tbias: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize") ⇒ Object 



2843
2844
2845
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2843

def self.quantized_depthwise_conv2_d_with_bias_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, tinput: nil, tfilter: nil, tbias: nil, out_type: :quint8, strides: nil, padding: nil, dilations: [], name: "QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize")
  self.execute("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output], Tinput: tinput, Tfilter: tfilter, Tbias: tbias, out_type: out_type, strides: strides, padding: padding, dilations: dilations, name: name)
end

.quantized_instance_norm(x, x_min, x_max, typeT: nil, output_range_given: false, given_y_min: 0.0, given_y_max: 0.0, variance_epsilon: 9.999999747378752e-06, min_separation: 0.0010000000474974513, name: "QuantizedInstanceNorm") ⇒ Object 



2847
2848
2849
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2847

def self.quantized_instance_norm(x, x_min, x_max, typeT: nil, output_range_given: false, given_y_min: 0.0, given_y_max: 0.0, variance_epsilon: 9.999999747378752e-06, min_separation: 0.0010000000474974513, name: "QuantizedInstanceNorm")
  self.execute("QuantizedInstanceNorm", [x, x_min, x_max], T: typeT, output_range_given: output_range_given, given_y_min: given_y_min, given_y_max: given_y_max, variance_epsilon: variance_epsilon, min_separation: min_separation, name: name)
end

.quantized_mat_mul(a, b, min_a, max_a, min_b, max_b, t1: nil, t2: nil, toutput: :qint32, transpose_a: false, transpose_b: false, tactivation: :quint8, name: "QuantizedMatMul") ⇒ Object 



2851
2852
2853
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2851

def self.quantized_mat_mul(a, b, min_a, max_a, min_b, max_b, t1: nil, t2: nil, toutput: :qint32, transpose_a: false, transpose_b: false, tactivation: :quint8, name: "QuantizedMatMul")
  self.execute("QuantizedMatMul", [a, b, min_a, max_a, min_b, max_b], T1: t1, T2: t2, Toutput: toutput, transpose_a: transpose_a, transpose_b: transpose_b, Tactivation: tactivation, name: name)
end

.quantized_mat_mul_with_bias(a, b, bias, min_a, max_a, min_b, max_b, t1: nil, t2: nil, tbias: nil, toutput: :qint32, transpose_a: false, transpose_b: false, input_quant_mode: "MIN_FIRST", name: "QuantizedMatMulWithBias") ⇒ Object 



2855
2856
2857
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2855

def self.quantized_mat_mul_with_bias(a, b, bias, min_a, max_a, min_b, max_b, t1: nil, t2: nil, tbias: nil, toutput: :qint32, transpose_a: false, transpose_b: false, input_quant_mode: "MIN_FIRST", name: "QuantizedMatMulWithBias")
  self.execute("QuantizedMatMulWithBias", [a, b, bias, min_a, max_a, min_b, max_b], T1: t1, T2: t2, Tbias: tbias, Toutput: toutput, transpose_a: transpose_a, transpose_b: transpose_b, input_quant_mode: input_quant_mode, name: name)
end

.quantized_mat_mul_with_bias_and_relu(a, b, bias, min_a, max_a, min_b, max_b, t1: nil, t2: nil, toutput: :qint32, transpose_a: false, transpose_b: false, input_quant_mode: "MIN_FIRST", name: "QuantizedMatMulWithBiasAndRelu") ⇒ Object 



2859
2860
2861
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2859

def self.quantized_mat_mul_with_bias_and_relu(a, b, bias, min_a, max_a, min_b, max_b, t1: nil, t2: nil, toutput: :qint32, transpose_a: false, transpose_b: false, input_quant_mode: "MIN_FIRST", name: "QuantizedMatMulWithBiasAndRelu")
  self.execute("QuantizedMatMulWithBiasAndRelu", [a, b, bias, min_a, max_a, min_b, max_b], T1: t1, T2: t2, Toutput: toutput, transpose_a: transpose_a, transpose_b: transpose_b, input_quant_mode: input_quant_mode, name: name)
end

.quantized_mat_mul_with_bias_and_relu_and_requantize(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, t1: nil, t2: nil, tbias: nil, toutput: :quint8, transpose_a: false, transpose_b: false, input_quant_mode: "MIN_FIRST", name: "QuantizedMatMulWithBiasAndReluAndRequantize") ⇒ Object 



2863
2864
2865
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2863

def self.quantized_mat_mul_with_bias_and_relu_and_requantize(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, t1: nil, t2: nil, tbias: nil, toutput: :quint8, transpose_a: false, transpose_b: false, input_quant_mode: "MIN_FIRST", name: "QuantizedMatMulWithBiasAndReluAndRequantize")
  self.execute("QuantizedMatMulWithBiasAndReluAndRequantize", [a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output], T1: t1, T2: t2, Tbias: tbias, Toutput: toutput, transpose_a: transpose_a, transpose_b: transpose_b, input_quant_mode: input_quant_mode, name: name)
end

.quantized_max_pool(input, min_input, max_input, typeT: nil, ksize: nil, strides: nil, padding: nil, name: "QuantizedMaxPool") ⇒ Object 



2867
2868
2869
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2867

def self.quantized_max_pool(input, min_input, max_input, typeT: nil, ksize: nil, strides: nil, padding: nil, name: "QuantizedMaxPool")
  self.execute("QuantizedMaxPool", [input, min_input, max_input], T: typeT, ksize: ksize, strides: strides, padding: padding, name: name)
end

.quantized_mul(x, y, min_x, max_x, min_y, max_y, t1: nil, t2: nil, toutput: :qint32, name: "QuantizedMul") ⇒ Object 



2871
2872
2873
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2871

def self.quantized_mul(x, y, min_x, max_x, min_y, max_y, t1: nil, t2: nil, toutput: :qint32, name: "QuantizedMul")
  self.execute("QuantizedMul", [x, y, min_x, max_x, min_y, max_y], T1: t1, T2: t2, Toutput: toutput, name: name)
end

.quantized_relu(features, min_features, max_features, tinput: nil, out_type: :quint8, name: "QuantizedRelu") ⇒ Object 



2875
2876
2877
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2875

def self.quantized_relu(features, min_features, max_features, tinput: nil, out_type: :quint8, name: "QuantizedRelu")
  self.execute("QuantizedRelu", [features, min_features, max_features], Tinput: tinput, out_type: out_type, name: name)
end

.quantized_relu6(features, min_features, max_features, tinput: nil, out_type: :quint8, name: "QuantizedRelu6") ⇒ Object 



2879
2880
2881
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2879

def self.quantized_relu6(features, min_features, max_features, tinput: nil, out_type: :quint8, name: "QuantizedRelu6")
  self.execute("QuantizedRelu6", [features, min_features, max_features], Tinput: tinput, out_type: out_type, name: name)
end

.quantized_relu_x(features, max_value, min_features, max_features, tinput: nil, out_type: :quint8, name: "QuantizedReluX") ⇒ Object 



2883
2884
2885
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2883

def self.quantized_relu_x(features, max_value, min_features, max_features, tinput: nil, out_type: :quint8, name: "QuantizedReluX")
  self.execute("QuantizedReluX", [features, max_value, min_features, max_features], Tinput: tinput, out_type: out_type, name: name)
end

.quantized_reshape(tensor, shape, input_min, input_max, typeT: nil, tshape: :int32, name: "QuantizedReshape") ⇒ Object 



2887
2888
2889
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2887

def self.quantized_reshape(tensor, shape, input_min, input_max, typeT: nil, tshape: :int32, name: "QuantizedReshape")
  self.execute("QuantizedReshape", [tensor, shape, input_min, input_max], T: typeT, Tshape: tshape, name: name)
end

.quantized_resize_bilinear(images, size, min, max, typeT: nil, align_corners: false, half_pixel_centers: false, name: "QuantizedResizeBilinear") ⇒ Object 



2891
2892
2893
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2891

def self.quantized_resize_bilinear(images, size, min, max, typeT: nil, align_corners: false, half_pixel_centers: false, name: "QuantizedResizeBilinear")
  self.execute("QuantizedResizeBilinear", [images, size, min, max], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.queue_close(handle, cancel_pending_enqueues: false, name: "QueueClose") ⇒ Object 



2895
2896
2897
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2895

def self.queue_close(handle, cancel_pending_enqueues: false, name: "QueueClose")
  self.execute("QueueClose", [handle], cancel_pending_enqueues: cancel_pending_enqueues, name: name)
end

.queue_close_v2(handle, cancel_pending_enqueues: false, name: "QueueCloseV2") ⇒ Object 



2899
2900
2901
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2899

def self.queue_close_v2(handle, cancel_pending_enqueues: false, name: "QueueCloseV2")
  self.execute("QueueCloseV2", [handle], cancel_pending_enqueues: cancel_pending_enqueues, name: name)
end

.queue_dequeue(handle, component_types: nil, timeout_ms: -1,, name: "QueueDequeue") ⇒ Object 



2903
2904
2905
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2903

def self.queue_dequeue(handle, component_types: nil, timeout_ms: -1, name: "QueueDequeue")
  self.execute("QueueDequeue", [handle], component_types: component_types, timeout_ms: timeout_ms, name: name)
end

.queue_dequeue_many(handle, n, component_types: nil, timeout_ms: -1,, name: "QueueDequeueMany") ⇒ Object 



2907
2908
2909
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2907

def self.queue_dequeue_many(handle, n, component_types: nil, timeout_ms: -1, name: "QueueDequeueMany")
  self.execute("QueueDequeueMany", [handle, n], component_types: component_types, timeout_ms: timeout_ms, name: name)
end

.queue_dequeue_many_v2(handle, n, component_types: nil, timeout_ms: -1,, name: "QueueDequeueManyV2") ⇒ Object 



2911
2912
2913
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2911

def self.queue_dequeue_many_v2(handle, n, component_types: nil, timeout_ms: -1, name: "QueueDequeueManyV2")
  self.execute("QueueDequeueManyV2", [handle, n], component_types: component_types, timeout_ms: timeout_ms, name: name)
end

.queue_dequeue_up_to(handle, n, component_types: nil, timeout_ms: -1,, name: "QueueDequeueUpTo") ⇒ Object 



2915
2916
2917
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2915

def self.queue_dequeue_up_to(handle, n, component_types: nil, timeout_ms: -1, name: "QueueDequeueUpTo")
  self.execute("QueueDequeueUpTo", [handle, n], component_types: component_types, timeout_ms: timeout_ms, name: name)
end

.queue_dequeue_up_to_v2(handle, n, component_types: nil, timeout_ms: -1,, name: "QueueDequeueUpToV2") ⇒ Object 



2919
2920
2921
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2919

def self.queue_dequeue_up_to_v2(handle, n, component_types: nil, timeout_ms: -1, name: "QueueDequeueUpToV2")
  self.execute("QueueDequeueUpToV2", [handle, n], component_types: component_types, timeout_ms: timeout_ms, name: name)
end

.queue_dequeue_v2(handle, component_types: nil, timeout_ms: -1,, name: "QueueDequeueV2") ⇒ Object 



2923
2924
2925
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2923

def self.queue_dequeue_v2(handle, component_types: nil, timeout_ms: -1, name: "QueueDequeueV2")
  self.execute("QueueDequeueV2", [handle], component_types: component_types, timeout_ms: timeout_ms, name: name)
end

.queue_enqueue(handle, components, tcomponents: nil, timeout_ms: -1,, name: "QueueEnqueue") ⇒ Object 



2927
2928
2929
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2927

def self.queue_enqueue(handle, components, tcomponents: nil, timeout_ms: -1, name: "QueueEnqueue")
  self.execute("QueueEnqueue", [handle, components], Tcomponents: tcomponents, timeout_ms: timeout_ms, name: name)
end

.queue_enqueue_many(handle, components, tcomponents: nil, timeout_ms: -1,, name: "QueueEnqueueMany") ⇒ Object 



2931
2932
2933
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2931

def self.queue_enqueue_many(handle, components, tcomponents: nil, timeout_ms: -1, name: "QueueEnqueueMany")
  self.execute("QueueEnqueueMany", [handle, components], Tcomponents: tcomponents, timeout_ms: timeout_ms, name: name)
end

.queue_enqueue_many_v2(handle, components, tcomponents: nil, timeout_ms: -1,, name: "QueueEnqueueManyV2") ⇒ Object 



2935
2936
2937
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2935

def self.queue_enqueue_many_v2(handle, components, tcomponents: nil, timeout_ms: -1, name: "QueueEnqueueManyV2")
  self.execute("QueueEnqueueManyV2", [handle, components], Tcomponents: tcomponents, timeout_ms: timeout_ms, name: name)
end

.queue_enqueue_v2(handle, components, tcomponents: nil, timeout_ms: -1,, name: "QueueEnqueueV2") ⇒ Object 



2939
2940
2941
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2939

def self.queue_enqueue_v2(handle, components, tcomponents: nil, timeout_ms: -1, name: "QueueEnqueueV2")
  self.execute("QueueEnqueueV2", [handle, components], Tcomponents: tcomponents, timeout_ms: timeout_ms, name: name)
end

.queue_is_closed(handle, name: "QueueIsClosed") ⇒ Object 



2943
2944
2945
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2943

def self.queue_is_closed(handle, name: "QueueIsClosed")
  self.execute("QueueIsClosed", [handle], name: name)
end

.queue_is_closed_v2(handle, name: "QueueIsClosedV2") ⇒ Object 



2947
2948
2949
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2947

def self.queue_is_closed_v2(handle, name: "QueueIsClosedV2")
  self.execute("QueueIsClosedV2", [handle], name: name)
end

.queue_size(handle, name: "QueueSize") ⇒ Object 



2951
2952
2953
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2951

def self.queue_size(handle, name: "QueueSize")
  self.execute("QueueSize", [handle], name: name)
end

.queue_size_v2(handle, name: "QueueSizeV2") ⇒ Object 



2955
2956
2957
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2955

def self.queue_size_v2(handle, name: "QueueSizeV2")
  self.execute("QueueSizeV2", [handle], name: name)
end

.ragged_gather(params_nested_splits, params_dense_values, indices, tvalues: nil, tindices: nil, tsplits: :int64, params_ragged_rank: nil, output_ragged_rank: nil, name: "RaggedGather") ⇒ Object 



2975
2976
2977
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2975

def self.ragged_gather(params_nested_splits, params_dense_values, indices, tvalues: nil, tindices: nil, tsplits: :int64, params_ragged_rank: nil, output_ragged_rank: nil, name: "RaggedGather")
  self.execute("RaggedGather", [params_nested_splits, params_dense_values, indices], Tvalues: tvalues, Tindices: tindices, Tsplits: tsplits, PARAMS_RAGGED_RANK: params_ragged_rank, OUTPUT_RAGGED_RANK: output_ragged_rank, name: name)
end

.ragged_range(starts, limits, deltas, typeT: :int32, tsplits: :int64, name: "RaggedRange") ⇒ Object 



2979
2980
2981
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2979

def self.ragged_range(starts, limits, deltas, typeT: :int32, tsplits: :int64, name: "RaggedRange")
  self.execute("RaggedRange", [starts, limits, deltas], T: typeT, Tsplits: tsplits, name: name)
end

.ragged_tensor_from_variant(encoded_ragged, input_ragged_rank: nil, output_ragged_rank: nil, tvalues: nil, tsplits: :int64, name: "RaggedTensorFromVariant") ⇒ Object 



2983
2984
2985
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2983

def self.ragged_tensor_from_variant(encoded_ragged, input_ragged_rank: nil, output_ragged_rank: nil, tvalues: nil, tsplits: :int64, name: "RaggedTensorFromVariant")
  self.execute("RaggedTensorFromVariant", [encoded_ragged], input_ragged_rank: input_ragged_rank, output_ragged_rank: output_ragged_rank, Tvalues: tvalues, Tsplits: tsplits, name: name)
end

.ragged_tensor_to_sparse(rt_nested_splits, rt_dense_values, ragged_rank: nil, typeT: nil, tsplits: :int64, name: "RaggedTensorToSparse") ⇒ Object 



2987
2988
2989
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2987

def self.ragged_tensor_to_sparse(rt_nested_splits, rt_dense_values, ragged_rank: nil, typeT: nil, tsplits: :int64, name: "RaggedTensorToSparse")
  self.execute("RaggedTensorToSparse", [rt_nested_splits, rt_dense_values], RAGGED_RANK: ragged_rank, T: typeT, Tsplits: tsplits, name: name)
end

.ragged_tensor_to_tensor(shape, values, default_value, row_partition_tensors, typeT: nil, tindex: nil, tshape: nil, num_row_partition_tensors: nil, row_partition_types: nil, name: "RaggedTensorToTensor") ⇒ Object 



2991
2992
2993
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2991

def self.ragged_tensor_to_tensor(shape, values, default_value, row_partition_tensors, typeT: nil, tindex: nil, tshape: nil, num_row_partition_tensors: nil, row_partition_types: nil, name: "RaggedTensorToTensor")
  self.execute("RaggedTensorToTensor", [shape, values, default_value, row_partition_tensors], T: typeT, Tindex: tindex, Tshape: tshape, num_row_partition_tensors: num_row_partition_tensors, row_partition_types: row_partition_types, name: name)
end

.ragged_tensor_to_variant(rt_nested_splits, rt_dense_values, ragged_rank: nil, tvalues: nil, tsplits: :int64, batched_input: nil, name: "RaggedTensorToVariant") ⇒ Object 



2995
2996
2997
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2995

def self.ragged_tensor_to_variant(rt_nested_splits, rt_dense_values, ragged_rank: nil, tvalues: nil, tsplits: :int64, batched_input: nil, name: "RaggedTensorToVariant")
  self.execute("RaggedTensorToVariant", [rt_nested_splits, rt_dense_values], RAGGED_RANK: ragged_rank, Tvalues: tvalues, Tsplits: tsplits, batched_input: batched_input, name: name)
end

.random_crop(image, size, typeT: nil, seed: 0, seed2: 0, name: "RandomCrop") ⇒ Object 



2999
3000
3001
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2999

def self.random_crop(image, size, typeT: nil, seed: 0, seed2: 0, name: "RandomCrop")
  self.execute("RandomCrop", [image, size], T: typeT, seed: seed, seed2: seed2, name: name)
end

.random_dataset(seed, seed2, output_types: nil, output_shapes: nil, name: "RandomDataset") ⇒ Object 



3003
3004
3005
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3003

def self.random_dataset(seed, seed2, output_types: nil, output_shapes: nil, name: "RandomDataset")
  self.execute("RandomDataset", [seed, seed2], output_types: output_types, output_shapes: output_shapes, name: name)
end

.random_gamma(shape, alpha, seed: 0, seed2: 0, s: nil, typeT: nil, name: "RandomGamma") ⇒ Object 



3007
3008
3009
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3007

def self.random_gamma(shape, alpha, seed: 0, seed2: 0, s: nil, typeT: nil, name: "RandomGamma")
  self.execute("RandomGamma", [shape, alpha], seed: seed, seed2: seed2, S: s, T: typeT, name: name)
end

.random_gamma_grad(alpha, sample, typeT: nil, name: "RandomGammaGrad") ⇒ Object 



3011
3012
3013
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3011

def self.random_gamma_grad(alpha, sample, typeT: nil, name: "RandomGammaGrad")
  self.execute("RandomGammaGrad", [alpha, sample], T: typeT, name: name)
end

.random_poisson(shape, rate, seed: 0, seed2: 0, s: nil, dtype: nil, name: "RandomPoisson") ⇒ Object 



3015
3016
3017
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3015

def self.random_poisson(shape, rate, seed: 0, seed2: 0, s: nil, dtype: nil, name: "RandomPoisson")
  self.execute("RandomPoisson", [shape, rate], seed: seed, seed2: seed2, S: s, dtype: dtype, name: name)
end

.random_poisson_v2(shape, rate, seed: 0, seed2: 0, s: nil, r: :double, dtype: :int64, name: "RandomPoissonV2") ⇒ Object 



3019
3020
3021
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3019

def self.random_poisson_v2(shape, rate, seed: 0, seed2: 0, s: nil, r: :double, dtype: :int64, name: "RandomPoissonV2")
  self.execute("RandomPoissonV2", [shape, rate], seed: seed, seed2: seed2, S: s, R: r, dtype: dtype, name: name)
end

.random_shuffle(value, seed: 0, seed2: 0, typeT: nil, name: "RandomShuffle") ⇒ Object 



3023
3024
3025
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3023

def self.random_shuffle(value, seed: 0, seed2: 0, typeT: nil, name: "RandomShuffle")
  self.execute("RandomShuffle", [value], seed: seed, seed2: seed2, T: typeT, name: name)
end

.random_shuffle_queue(component_types: nil, shapes: [], capacity: -1,, min_after_dequeue: 0, seed: 0, seed2: 0, container: "", shared_name: "", name: "RandomShuffleQueue") ⇒ Object 



3027
3028
3029
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3027

def self.random_shuffle_queue(component_types: nil, shapes: [], capacity: -1, min_after_dequeue: 0, seed: 0, seed2: 0, container: "", shared_name: "", name: "RandomShuffleQueue")
  self.execute("RandomShuffleQueue", [], component_types: component_types, shapes: shapes, capacity: capacity, min_after_dequeue: min_after_dequeue, seed: seed, seed2: seed2, container: container, shared_name: shared_name, name: name)
end

.random_shuffle_queue_v2(component_types: nil, shapes: [], capacity: -1,, min_after_dequeue: 0, seed: 0, seed2: 0, container: "", shared_name: "", name: "RandomShuffleQueueV2") ⇒ Object 



3031
3032
3033
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3031

def self.random_shuffle_queue_v2(component_types: nil, shapes: [], capacity: -1, min_after_dequeue: 0, seed: 0, seed2: 0, container: "", shared_name: "", name: "RandomShuffleQueueV2")
  self.execute("RandomShuffleQueueV2", [], component_types: component_types, shapes: shapes, capacity: capacity, min_after_dequeue: min_after_dequeue, seed: seed, seed2: seed2, container: container, shared_name: shared_name, name: name)
end

.random_standard_normal(shape, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "RandomStandardNormal") ⇒ Object 



3035
3036
3037
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3035

def self.random_standard_normal(shape, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "RandomStandardNormal")
  self.execute("RandomStandardNormal", [shape], seed: seed, seed2: seed2, dtype: dtype, T: typeT, name: name)
end

.random_uniform(shape, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "RandomUniform") ⇒ Object 



3039
3040
3041
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3039

def self.random_uniform(shape, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "RandomUniform")
  self.execute("RandomUniform", [shape], seed: seed, seed2: seed2, dtype: dtype, T: typeT, name: name)
end

.random_uniform_int(shape, minval, maxval, seed: 0, seed2: 0, tout: nil, typeT: nil, name: "RandomUniformInt") ⇒ Object 



3043
3044
3045
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3043

def self.random_uniform_int(shape, minval, maxval, seed: 0, seed2: 0, tout: nil, typeT: nil, name: "RandomUniformInt")
  self.execute("RandomUniformInt", [shape, minval, maxval], seed: seed, seed2: seed2, Tout: tout, T: typeT, name: name)
end

.range(start, limit, delta, tidx: :int32, name: "Range") ⇒ Object 



3047
3048
3049
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3047

def self.range(start, limit, delta, tidx: :int32, name: "Range")
  self.execute("Range", [start, limit, delta], Tidx: tidx, name: name)
end

.range_dataset(start, stop, step, output_types: nil, output_shapes: nil, name: "RangeDataset") ⇒ Object 



3051
3052
3053
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3051

def self.range_dataset(start, stop, step, output_types: nil, output_shapes: nil, name: "RangeDataset")
  self.execute("RangeDataset", [start, stop, step], output_types: output_types, output_shapes: output_shapes, name: name)
end

.rank(input, typeT: nil, name: "Rank") ⇒ Object 



3055
3056
3057
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3055

def self.rank(input, typeT: nil, name: "Rank")
  self.execute("Rank", [input], T: typeT, name: name)
end

.read_file(filename, name: "ReadFile") ⇒ Object 



3059
3060
3061
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3059

def self.read_file(filename, name: "ReadFile")
  self.execute("ReadFile", [filename], name: name)
end

.read_variable_op(resource, dtype: nil, name: "ReadVariableOp") ⇒ Object 



3063
3064
3065
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3063

def self.read_variable_op(resource, dtype: nil, name: "ReadVariableOp")
  self.execute("ReadVariableOp", [resource], dtype: dtype, name: name)
end

.reader_num_records_produced(reader_handle, name: "ReaderNumRecordsProduced") ⇒ Object 



3067
3068
3069
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3067

def self.reader_num_records_produced(reader_handle, name: "ReaderNumRecordsProduced")
  self.execute("ReaderNumRecordsProduced", [reader_handle], name: name)
end

.reader_num_records_produced_v2(reader_handle, name: "ReaderNumRecordsProducedV2") ⇒ Object 



3071
3072
3073
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3071

def self.reader_num_records_produced_v2(reader_handle, name: "ReaderNumRecordsProducedV2")
  self.execute("ReaderNumRecordsProducedV2", [reader_handle], name: name)
end

.reader_num_work_units_completed(reader_handle, name: "ReaderNumWorkUnitsCompleted") ⇒ Object 



3075
3076
3077
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3075

def self.reader_num_work_units_completed(reader_handle, name: "ReaderNumWorkUnitsCompleted")
  self.execute("ReaderNumWorkUnitsCompleted", [reader_handle], name: name)
end

.reader_num_work_units_completed_v2(reader_handle, name: "ReaderNumWorkUnitsCompletedV2") ⇒ Object 



3079
3080
3081
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3079

def self.reader_num_work_units_completed_v2(reader_handle, name: "ReaderNumWorkUnitsCompletedV2")
  self.execute("ReaderNumWorkUnitsCompletedV2", [reader_handle], name: name)
end

.reader_read(reader_handle, queue_handle, name: "ReaderRead") ⇒ Object 



3083
3084
3085
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3083

def self.reader_read(reader_handle, queue_handle, name: "ReaderRead")
  self.execute("ReaderRead", [reader_handle, queue_handle], name: name)
end

.reader_read_up_to(reader_handle, queue_handle, num_records, name: "ReaderReadUpTo") ⇒ Object 



3087
3088
3089
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3087

def self.reader_read_up_to(reader_handle, queue_handle, num_records, name: "ReaderReadUpTo")
  self.execute("ReaderReadUpTo", [reader_handle, queue_handle, num_records], name: name)
end

.reader_read_up_to_v2(reader_handle, queue_handle, num_records, name: "ReaderReadUpToV2") ⇒ Object 



3091
3092
3093
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3091

def self.reader_read_up_to_v2(reader_handle, queue_handle, num_records, name: "ReaderReadUpToV2")
  self.execute("ReaderReadUpToV2", [reader_handle, queue_handle, num_records], name: name)
end

.reader_read_v2(reader_handle, queue_handle, name: "ReaderReadV2") ⇒ Object 



3095
3096
3097
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3095

def self.reader_read_v2(reader_handle, queue_handle, name: "ReaderReadV2")
  self.execute("ReaderReadV2", [reader_handle, queue_handle], name: name)
end

.reader_reset(reader_handle, name: "ReaderReset") ⇒ Object 



3099
3100
3101
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3099

def self.reader_reset(reader_handle, name: "ReaderReset")
  self.execute("ReaderReset", [reader_handle], name: name)
end

.reader_reset_v2(reader_handle, name: "ReaderResetV2") ⇒ Object 



3103
3104
3105
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3103

def self.reader_reset_v2(reader_handle, name: "ReaderResetV2")
  self.execute("ReaderResetV2", [reader_handle], name: name)
end

.reader_restore_state(reader_handle, state, name: "ReaderRestoreState") ⇒ Object 



3107
3108
3109
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3107

def self.reader_restore_state(reader_handle, state, name: "ReaderRestoreState")
  self.execute("ReaderRestoreState", [reader_handle, state], name: name)
end

.reader_restore_state_v2(reader_handle, state, name: "ReaderRestoreStateV2") ⇒ Object 



3111
3112
3113
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3111

def self.reader_restore_state_v2(reader_handle, state, name: "ReaderRestoreStateV2")
  self.execute("ReaderRestoreStateV2", [reader_handle, state], name: name)
end

.reader_serialize_state(reader_handle, name: "ReaderSerializeState") ⇒ Object 



3115
3116
3117
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3115

def self.reader_serialize_state(reader_handle, name: "ReaderSerializeState")
  self.execute("ReaderSerializeState", [reader_handle], name: name)
end

.reader_serialize_state_v2(reader_handle, name: "ReaderSerializeStateV2") ⇒ Object 



3119
3120
3121
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3119

def self.reader_serialize_state_v2(reader_handle, name: "ReaderSerializeStateV2")
  self.execute("ReaderSerializeStateV2", [reader_handle], name: name)
end

.real(input, typeT: :complex64, tout: :float, name: "Real") ⇒ Object 



3123
3124
3125
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3123

def self.real(input, typeT: :complex64, tout: :float, name: "Real")
  self.execute("Real", [input], T: typeT, Tout: tout, name: name)
end

.real_div(x, y, typeT: nil, name: "RealDiv") ⇒ Object 



3127
3128
3129
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3127

def self.real_div(x, y, typeT: nil, name: "RealDiv")
  self.execute("RealDiv", [x, y], T: typeT, name: name)
end

.rebatch_dataset(input_dataset, num_replicas, output_types: nil, output_shapes: nil, use_fallback: true, name: "RebatchDataset") ⇒ Object 



3131
3132
3133
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3131

def self.rebatch_dataset(input_dataset, num_replicas, output_types: nil, output_shapes: nil, use_fallback: true, name: "RebatchDataset")
  self.execute("RebatchDataset", [input_dataset, num_replicas], output_types: output_types, output_shapes: output_shapes, use_fallback: use_fallback, name: name)
end

.reciprocal(x, typeT: nil, name: "Reciprocal") ⇒ Object 



3135
3136
3137
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3135

def self.reciprocal(x, typeT: nil, name: "Reciprocal")
  self.execute("Reciprocal", [x], T: typeT, name: name)
end

.reciprocal_grad(y, dy, typeT: nil, name: "ReciprocalGrad") ⇒ Object 



3139
3140
3141
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3139

def self.reciprocal_grad(y, dy, typeT: nil, name: "ReciprocalGrad")
  self.execute("ReciprocalGrad", [y, dy], T: typeT, name: name)
end

.record_input(file_pattern: "", file_random_seed: 301, file_shuffle_shift_ratio: 0.0, file_buffer_size: 10000, file_parallelism: 16, batch_size: 32, compression_type: "", name: "RecordInput") ⇒ Object 



3143
3144
3145
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3143

def self.record_input(file_pattern: "", file_random_seed: 301, file_shuffle_shift_ratio: 0.0, file_buffer_size: 10000, file_parallelism: 16, batch_size: 32, compression_type: "", name: "RecordInput")
  self.execute("RecordInput", [], file_pattern: file_pattern, file_random_seed: file_random_seed, file_shuffle_shift_ratio: file_shuffle_shift_ratio, file_buffer_size: file_buffer_size, file_parallelism: file_parallelism, batch_size: batch_size, compression_type: compression_type, name: name)
end

.recv(tensor_type: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "Recv") ⇒ Object 



3147
3148
3149
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3147

def self.recv(tensor_type: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "Recv")
  self.execute("Recv", [], tensor_type: tensor_type, tensor_name: tensor_name, send_device: send_device, send_device_incarnation: send_device_incarnation, recv_device: recv_device, client_terminated: client_terminated, name: name)
end

.recv_tpu_embedding_activations(num_outputs: nil, config: "", name: "RecvTPUEmbeddingActivations") ⇒ Object 



3151
3152
3153
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3151

def self.recv_tpu_embedding_activations(num_outputs: nil, config: "", name: "RecvTPUEmbeddingActivations")
  self.execute("RecvTPUEmbeddingActivations", [], num_outputs: num_outputs, config: config, name: name)
end

.reduce_dataset(input_dataset, initial_state, other_arguments, f: nil, tstate: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, name: "ReduceDataset") ⇒ Object 



3155
3156
3157
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3155

def self.reduce_dataset(input_dataset, initial_state, other_arguments, f: nil, tstate: nil, targuments: nil, output_types: nil, output_shapes: nil, use_inter_op_parallelism: true, name: "ReduceDataset")
  self.execute("ReduceDataset", [input_dataset, initial_state, other_arguments], f: f, Tstate: tstate, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, use_inter_op_parallelism: use_inter_op_parallelism, name: name)
end

.reduce_join(inputs, reduction_indices, keep_dims: false, separator: "", name: "ReduceJoin") ⇒ Object 



3159
3160
3161
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3159

def self.reduce_join(inputs, reduction_indices, keep_dims: false, separator: "", name: "ReduceJoin")
  self.execute("ReduceJoin", [inputs, reduction_indices], keep_dims: keep_dims, separator: separator, name: name)
end

.ref_enter(data, typeT: nil, frame_name: "", is_constant: false, parallel_iterations: 10, name: "RefEnter") ⇒ Object 



3163
3164
3165
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3163

def self.ref_enter(data, typeT: nil, frame_name: "", is_constant: false, parallel_iterations: 10, name: "RefEnter")
  self.execute("RefEnter", [data], T: typeT, frame_name: frame_name, is_constant: is_constant, parallel_iterations: parallel_iterations, name: name)
end

.ref_exit(data, typeT: nil, name: "RefExit") ⇒ Object 



3167
3168
3169
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3167

def self.ref_exit(data, typeT: nil, name: "RefExit")
  self.execute("RefExit", [data], T: typeT, name: name)
end

.ref_identity(input, typeT: nil, name: "RefIdentity") ⇒ Object 



3171
3172
3173
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3171

def self.ref_identity(input, typeT: nil, name: "RefIdentity")
  self.execute("RefIdentity", [input], T: typeT, name: name)
end

.ref_merge(inputs, typeT: nil, n: nil, name: "RefMerge") ⇒ Object 



3175
3176
3177
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3175

def self.ref_merge(inputs, typeT: nil, n: nil, name: "RefMerge")
  self.execute("RefMerge", [inputs], T: typeT, N: n, name: name)
end

.ref_next_iteration(data, typeT: nil, name: "RefNextIteration") ⇒ Object 



3179
3180
3181
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3179

def self.ref_next_iteration(data, typeT: nil, name: "RefNextIteration")
  self.execute("RefNextIteration", [data], T: typeT, name: name)
end

.ref_select(index, inputs, typeT: nil, n: nil, name: "RefSelect") ⇒ Object 



3183
3184
3185
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3183

def self.ref_select(index, inputs, typeT: nil, n: nil, name: "RefSelect")
  self.execute("RefSelect", [index, inputs], T: typeT, N: n, name: name)
end

.ref_switch(data, pred, typeT: nil, name: "RefSwitch") ⇒ Object 



3187
3188
3189
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3187

def self.ref_switch(data, pred, typeT: nil, name: "RefSwitch")
  self.execute("RefSwitch", [data, pred], T: typeT, name: name)
end

.regex_full_match(input, pattern, name: "RegexFullMatch") ⇒ Object 



3191
3192
3193
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3191

def self.regex_full_match(input, pattern, name: "RegexFullMatch")
  self.execute("RegexFullMatch", [input, pattern], name: name)
end

.regex_replace(input, pattern, rewrite, replace_global: true, name: "RegexReplace") ⇒ Object 



3195
3196
3197
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3195

def self.regex_replace(input, pattern, rewrite, replace_global: true, name: "RegexReplace")
  self.execute("RegexReplace", [input, pattern, rewrite], replace_global: replace_global, name: name)
end

.relu(features, typeT: nil, name: "Relu") ⇒ Object 



3199
3200
3201
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3199

def self.relu(features, typeT: nil, name: "Relu")
  self.execute("Relu", [features], T: typeT, name: name)
end

.relu6(features, typeT: nil, name: "Relu6") ⇒ Object 



3203
3204
3205
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3203

def self.relu6(features, typeT: nil, name: "Relu6")
  self.execute("Relu6", [features], T: typeT, name: name)
end

.relu6_grad(gradients, features, typeT: nil, name: "Relu6Grad") ⇒ Object 



3207
3208
3209
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3207

def self.relu6_grad(gradients, features, typeT: nil, name: "Relu6Grad")
  self.execute("Relu6Grad", [gradients, features], T: typeT, name: name)
end

.relu_grad(gradients, features, typeT: nil, name: "ReluGrad") ⇒ Object 



3211
3212
3213
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3211

def self.relu_grad(gradients, features, typeT: nil, name: "ReluGrad")
  self.execute("ReluGrad", [gradients, features], T: typeT, name: name)
end

.remote_call(target, args, tin: nil, tout: nil, f: nil, name: "RemoteCall") ⇒ Object 



3215
3216
3217
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3215

def self.remote_call(target, args, tin: nil, tout: nil, f: nil, name: "RemoteCall")
  self.execute("RemoteCall", [target, args], Tin: tin, Tout: tout, f: f, name: name)
end

.remote_fused_graph_execute(inputs, tinputs: nil, toutputs: nil, serialized_remote_fused_graph_execute_info: "", name: "RemoteFusedGraphExecute") ⇒ Object 



3219
3220
3221
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3219

def self.remote_fused_graph_execute(inputs, tinputs: nil, toutputs: nil, serialized_remote_fused_graph_execute_info: "", name: "RemoteFusedGraphExecute")
  self.execute("RemoteFusedGraphExecute", [inputs], Tinputs: tinputs, Toutputs: toutputs, serialized_remote_fused_graph_execute_info: serialized_remote_fused_graph_execute_info, name: name)
end

.repeat_dataset(input_dataset, count, output_types: nil, output_shapes: nil, name: "RepeatDataset") ⇒ Object 



3223
3224
3225
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3223

def self.repeat_dataset(input_dataset, count, output_types: nil, output_shapes: nil, name: "RepeatDataset")
  self.execute("RepeatDataset", [input_dataset, count], output_types: output_types, output_shapes: output_shapes, name: name)
end

.requantization_range(input, input_min, input_max, tinput: nil, name: "RequantizationRange") ⇒ Object 



3227
3228
3229
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3227

def self.requantization_range(input, input_min, input_max, tinput: nil, name: "RequantizationRange")
  self.execute("RequantizationRange", [input, input_min, input_max], Tinput: tinput, name: name)
end

.requantization_range_per_channel(input, input_min, input_max, typeT: :qint32, clip_value_max: nil, name: "RequantizationRangePerChannel") ⇒ Object 



3231
3232
3233
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3231

def self.requantization_range_per_channel(input, input_min, input_max, typeT: :qint32, clip_value_max: nil, name: "RequantizationRangePerChannel")
  self.execute("RequantizationRangePerChannel", [input, input_min, input_max], T: typeT, clip_value_max: clip_value_max, name: name)
end

.requantize(input, input_min, input_max, requested_output_min, requested_output_max, tinput: nil, out_type: nil, name: "Requantize") ⇒ Object 



3235
3236
3237
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3235

def self.requantize(input, input_min, input_max, requested_output_min, requested_output_max, tinput: nil, out_type: nil, name: "Requantize")
  self.execute("Requantize", [input, input_min, input_max, requested_output_min, requested_output_max], Tinput: tinput, out_type: out_type, name: name)
end

.requantize_per_channel(input, input_min, input_max, requested_output_min, requested_output_max, typeT: :qint32, out_type: :quint8, name: "RequantizePerChannel") ⇒ Object 



3239
3240
3241
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3239

def self.requantize_per_channel(input, input_min, input_max, requested_output_min, requested_output_max, typeT: :qint32, out_type: :quint8, name: "RequantizePerChannel")
  self.execute("RequantizePerChannel", [input, input_min, input_max, requested_output_min, requested_output_max], T: typeT, out_type: out_type, name: name)
end

.reshape(tensor, shape, typeT: nil, tshape: :int32, name: "Reshape") ⇒ Object 



3243
3244
3245
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3243

def self.reshape(tensor, shape, typeT: nil, tshape: :int32, name: "Reshape")
  self.execute("Reshape", [tensor, shape], T: typeT, Tshape: tshape, name: name)
end

.resize_area(images, size, typeT: nil, align_corners: false, name: "ResizeArea") ⇒ Object 



3247
3248
3249
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3247

def self.resize_area(images, size, typeT: nil, align_corners: false, name: "ResizeArea")
  self.execute("ResizeArea", [images, size], T: typeT, align_corners: align_corners, name: name)
end

.resize_bicubic(images, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBicubic") ⇒ Object 



3251
3252
3253
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3251

def self.resize_bicubic(images, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBicubic")
  self.execute("ResizeBicubic", [images, size], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.resize_bicubic_grad(grads, original_image, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBicubicGrad") ⇒ Object 



3255
3256
3257
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3255

def self.resize_bicubic_grad(grads, original_image, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBicubicGrad")
  self.execute("ResizeBicubicGrad", [grads, original_image], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.resize_bilinear(images, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBilinear") ⇒ Object 



3259
3260
3261
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3259

def self.resize_bilinear(images, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBilinear")
  self.execute("ResizeBilinear", [images, size], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.resize_bilinear_grad(grads, original_image, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBilinearGrad") ⇒ Object 



3263
3264
3265
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3263

def self.resize_bilinear_grad(grads, original_image, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeBilinearGrad")
  self.execute("ResizeBilinearGrad", [grads, original_image], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.resize_nearest_neighbor(images, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeNearestNeighbor") ⇒ Object 



3267
3268
3269
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3267

def self.resize_nearest_neighbor(images, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeNearestNeighbor")
  self.execute("ResizeNearestNeighbor", [images, size], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.resize_nearest_neighbor_grad(grads, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeNearestNeighborGrad") ⇒ Object 



3271
3272
3273
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3271

def self.resize_nearest_neighbor_grad(grads, size, typeT: nil, align_corners: false, half_pixel_centers: false, name: "ResizeNearestNeighborGrad")
  self.execute("ResizeNearestNeighborGrad", [grads, size], T: typeT, align_corners: align_corners, half_pixel_centers: half_pixel_centers, name: name)
end

.resource_accumulator_apply_gradient(handle, local_step, gradient, dtype: nil, name: "ResourceAccumulatorApplyGradient") ⇒ Object 



3275
3276
3277
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3275

def self.resource_accumulator_apply_gradient(handle, local_step, gradient, dtype: nil, name: "ResourceAccumulatorApplyGradient")
  self.execute("ResourceAccumulatorApplyGradient", [handle, local_step, gradient], dtype: dtype, name: name)
end

.resource_accumulator_num_accumulated(handle, name: "ResourceAccumulatorNumAccumulated") ⇒ Object 



3279
3280
3281
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3279

def self.resource_accumulator_num_accumulated(handle, name: "ResourceAccumulatorNumAccumulated")
  self.execute("ResourceAccumulatorNumAccumulated", [handle], name: name)
end

.resource_accumulator_set_global_step(handle, new_global_step, name: "ResourceAccumulatorSetGlobalStep") ⇒ Object 



3283
3284
3285
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3283

def self.resource_accumulator_set_global_step(handle, new_global_step, name: "ResourceAccumulatorSetGlobalStep")
  self.execute("ResourceAccumulatorSetGlobalStep", [handle, new_global_step], name: name)
end

.resource_accumulator_take_gradient(handle, num_required, dtype: nil, name: "ResourceAccumulatorTakeGradient") ⇒ Object 



3287
3288
3289
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3287

def self.resource_accumulator_take_gradient(handle, num_required, dtype: nil, name: "ResourceAccumulatorTakeGradient")
  self.execute("ResourceAccumulatorTakeGradient", [handle, num_required], dtype: dtype, name: name)
end

.resource_apply_ada_max(var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyAdaMax") ⇒ Object 



3291
3292
3293
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3291

def self.resource_apply_ada_max(var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyAdaMax")
  self.execute("ResourceApplyAdaMax", [var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyAdadelta") ⇒ Object 



3295
3296
3297
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3295

def self.resource_apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyAdadelta")
  self.execute("ResourceApplyAdadelta", [var, accum, accum_update, lr, rho, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_adagrad(var, accum, lr, grad, typeT: nil, use_locking: false, update_slots: true, name: "ResourceApplyAdagrad") ⇒ Object 



3299
3300
3301
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3299

def self.resource_apply_adagrad(var, accum, lr, grad, typeT: nil, use_locking: false, update_slots: true, name: "ResourceApplyAdagrad")
  self.execute("ResourceApplyAdagrad", [var, accum, lr, grad], T: typeT, use_locking: use_locking, update_slots: update_slots, name: name)
end

.resource_apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step, typeT: nil, use_locking: false, name: "ResourceApplyAdagradDA") ⇒ Object 



3303
3304
3305
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3303

def self.resource_apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step, typeT: nil, use_locking: false, name: "ResourceApplyAdagradDA")
  self.execute("ResourceApplyAdagradDA", [var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_adagrad_v2(var, accum, lr, epsilon, grad, typeT: nil, use_locking: false, update_slots: true, name: "ResourceApplyAdagradV2") ⇒ Object 



3307
3308
3309
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3307

def self.resource_apply_adagrad_v2(var, accum, lr, epsilon, grad, typeT: nil, use_locking: false, update_slots: true, name: "ResourceApplyAdagradV2")
  self.execute("ResourceApplyAdagradV2", [var, accum, lr, epsilon, grad], T: typeT, use_locking: use_locking, update_slots: update_slots, name: name)
end

.resource_apply_adam(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, use_nesterov: false, name: "ResourceApplyAdam") ⇒ Object 



3311
3312
3313
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3311

def self.resource_apply_adam(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, use_nesterov: false, name: "ResourceApplyAdam")
  self.execute("ResourceApplyAdam", [var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad], T: typeT, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.resource_apply_adam_with_amsgrad(var, m, v, vhat, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyAdamWithAmsgrad") ⇒ Object 



3315
3316
3317
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3315

def self.resource_apply_adam_with_amsgrad(var, m, v, vhat, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyAdamWithAmsgrad")
  self.execute("ResourceApplyAdamWithAmsgrad", [var, m, v, vhat, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_add_sign(var, m, lr, alpha, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ResourceApplyAddSign") ⇒ Object 



3319
3320
3321
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3319

def self.resource_apply_add_sign(var, m, lr, alpha, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ResourceApplyAddSign")
  self.execute("ResourceApplyAddSign", [var, m, lr, alpha, sign_decay, beta, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyCenteredRMSProp") ⇒ Object 



3323
3324
3325
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3323

def self.resource_apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyCenteredRMSProp")
  self.execute("ResourceApplyCenteredRMSProp", [var, mg, ms, mom, lr, rho, momentum, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_ftrl(var, accum, linear, grad, lr, l1, l2, lr_power, typeT: nil, use_locking: false, name: "ResourceApplyFtrl") ⇒ Object 



3327
3328
3329
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3327

def self.resource_apply_ftrl(var, accum, linear, grad, lr, l1, l2, lr_power, typeT: nil, use_locking: false, name: "ResourceApplyFtrl")
  self.execute("ResourceApplyFtrl", [var, accum, linear, grad, lr, l1, l2, lr_power], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_ftrl_v2(var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, use_locking: false, name: "ResourceApplyFtrlV2") ⇒ Object 



3331
3332
3333
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3331

def self.resource_apply_ftrl_v2(var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, use_locking: false, name: "ResourceApplyFtrlV2")
  self.execute("ResourceApplyFtrlV2", [var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_gradient_descent(var, alpha, delta, typeT: nil, use_locking: false, name: "ResourceApplyGradientDescent") ⇒ Object 



3335
3336
3337
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3335

def self.resource_apply_gradient_descent(var, alpha, delta, typeT: nil, use_locking: false, name: "ResourceApplyGradientDescent")
  self.execute("ResourceApplyGradientDescent", [var, alpha, delta], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_keras_momentum(var, accum, lr, grad, momentum, typeT: nil, use_locking: false, use_nesterov: false, name: "ResourceApplyKerasMomentum") ⇒ Object 



3339
3340
3341
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3339

def self.resource_apply_keras_momentum(var, accum, lr, grad, momentum, typeT: nil, use_locking: false, use_nesterov: false, name: "ResourceApplyKerasMomentum")
  self.execute("ResourceApplyKerasMomentum", [var, accum, lr, grad, momentum], T: typeT, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.resource_apply_momentum(var, accum, lr, grad, momentum, typeT: nil, use_locking: false, use_nesterov: false, name: "ResourceApplyMomentum") ⇒ Object 



3343
3344
3345
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3343

def self.resource_apply_momentum(var, accum, lr, grad, momentum, typeT: nil, use_locking: false, use_nesterov: false, name: "ResourceApplyMomentum")
  self.execute("ResourceApplyMomentum", [var, accum, lr, grad, momentum], T: typeT, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.resource_apply_power_sign(var, m, lr, logbase, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ResourceApplyPowerSign") ⇒ Object 



3347
3348
3349
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3347

def self.resource_apply_power_sign(var, m, lr, logbase, sign_decay, beta, grad, typeT: nil, use_locking: false, name: "ResourceApplyPowerSign")
  self.execute("ResourceApplyPowerSign", [var, m, lr, logbase, sign_decay, beta, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_proximal_adagrad(var, accum, lr, l1, l2, grad, typeT: nil, use_locking: false, name: "ResourceApplyProximalAdagrad") ⇒ Object 



3351
3352
3353
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3351

def self.resource_apply_proximal_adagrad(var, accum, lr, l1, l2, grad, typeT: nil, use_locking: false, name: "ResourceApplyProximalAdagrad")
  self.execute("ResourceApplyProximalAdagrad", [var, accum, lr, l1, l2, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_proximal_gradient_descent(var, alpha, l1, l2, delta, typeT: nil, use_locking: false, name: "ResourceApplyProximalGradientDescent") ⇒ Object 



3355
3356
3357
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3355

def self.resource_apply_proximal_gradient_descent(var, alpha, l1, l2, delta, typeT: nil, use_locking: false, name: "ResourceApplyProximalGradientDescent")
  self.execute("ResourceApplyProximalGradientDescent", [var, alpha, l1, l2, delta], T: typeT, use_locking: use_locking, name: name)
end

.resource_apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyRMSProp") ⇒ Object 



3359
3360
3361
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3359

def self.resource_apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, typeT: nil, use_locking: false, name: "ResourceApplyRMSProp")
  self.execute("ResourceApplyRMSProp", [var, ms, mom, lr, rho, momentum, epsilon, grad], T: typeT, use_locking: use_locking, name: name)
end

.resource_conditional_accumulator(dtype: nil, shape: nil, container: "", shared_name: "", reduction_type: "MEAN", name: "ResourceConditionalAccumulator") ⇒ Object 



3363
3364
3365
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3363

def self.resource_conditional_accumulator(dtype: nil, shape: nil, container: "", shared_name: "", reduction_type: "MEAN", name: "ResourceConditionalAccumulator")
  self.execute("ResourceConditionalAccumulator", [], dtype: dtype, shape: shape, container: container, shared_name: shared_name, reduction_type: reduction_type, name: name)
end

.resource_count_up_to(resource, limit: nil, typeT: nil, name: "ResourceCountUpTo") ⇒ Object 



3367
3368
3369
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3367

def self.resource_count_up_to(resource, limit: nil, typeT: nil, name: "ResourceCountUpTo")
  self.execute("ResourceCountUpTo", [resource], limit: limit, T: typeT, name: name)
end

.resource_gather(resource, indices, batch_dims: 0, validate_indices: true, dtype: nil, tindices: nil, name: "ResourceGather") ⇒ Object 



3371
3372
3373
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3371

def self.resource_gather(resource, indices, batch_dims: 0, validate_indices: true, dtype: nil, tindices: nil, name: "ResourceGather")
  self.execute("ResourceGather", [resource, indices], batch_dims: batch_dims, validate_indices: validate_indices, dtype: dtype, Tindices: tindices, name: name)
end

.resource_gather_nd(resource, indices, dtype: nil, tindices: nil, name: "ResourceGatherNd") ⇒ Object 



3375
3376
3377
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3375

def self.resource_gather_nd(resource, indices, dtype: nil, tindices: nil, name: "ResourceGatherNd")
  self.execute("ResourceGatherNd", [resource, indices], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_add(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterAdd") ⇒ Object 



3379
3380
3381
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3379

def self.resource_scatter_add(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterAdd")
  self.execute("ResourceScatterAdd", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_div(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterDiv") ⇒ Object 



3383
3384
3385
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3383

def self.resource_scatter_div(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterDiv")
  self.execute("ResourceScatterDiv", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_max(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterMax") ⇒ Object 



3387
3388
3389
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3387

def self.resource_scatter_max(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterMax")
  self.execute("ResourceScatterMax", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_min(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterMin") ⇒ Object 



3391
3392
3393
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3391

def self.resource_scatter_min(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterMin")
  self.execute("ResourceScatterMin", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_mul(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterMul") ⇒ Object 



3395
3396
3397
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3395

def self.resource_scatter_mul(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterMul")
  self.execute("ResourceScatterMul", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_nd_add(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ResourceScatterNdAdd") ⇒ Object 



3399
3400
3401
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3399

def self.resource_scatter_nd_add(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ResourceScatterNdAdd")
  self.execute("ResourceScatterNdAdd", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_scatter_nd_sub(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ResourceScatterNdSub") ⇒ Object 



3403
3404
3405
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3403

def self.resource_scatter_nd_sub(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ResourceScatterNdSub")
  self.execute("ResourceScatterNdSub", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_scatter_nd_update(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ResourceScatterNdUpdate") ⇒ Object 



3407
3408
3409
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3407

def self.resource_scatter_nd_update(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ResourceScatterNdUpdate")
  self.execute("ResourceScatterNdUpdate", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_scatter_sub(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterSub") ⇒ Object 



3411
3412
3413
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3411

def self.resource_scatter_sub(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterSub")
  self.execute("ResourceScatterSub", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_scatter_update(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterUpdate") ⇒ Object 



3415
3416
3417
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3415

def self.resource_scatter_update(resource, indices, updates, dtype: nil, tindices: nil, name: "ResourceScatterUpdate")
  self.execute("ResourceScatterUpdate", [resource, indices, updates], dtype: dtype, Tindices: tindices, name: name)
end

.resource_sparse_apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyAdadelta") ⇒ Object 



3419
3420
3421
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3419

def self.resource_sparse_apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyAdadelta")
  self.execute("ResourceSparseApplyAdadelta", [var, accum, accum_update, lr, rho, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_adagrad(var, accum, lr, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "ResourceSparseApplyAdagrad") ⇒ Object 



3423
3424
3425
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3423

def self.resource_sparse_apply_adagrad(var, accum, lr, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "ResourceSparseApplyAdagrad")
  self.execute("ResourceSparseApplyAdagrad", [var, accum, lr, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, update_slots: update_slots, name: name)
end

.resource_sparse_apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyAdagradDA") ⇒ Object 



3427
3428
3429
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3427

def self.resource_sparse_apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyAdagradDA")
  self.execute("ResourceSparseApplyAdagradDA", [var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_adagrad_v2(var, accum, lr, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "ResourceSparseApplyAdagradV2") ⇒ Object 



3431
3432
3433
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3431

def self.resource_sparse_apply_adagrad_v2(var, accum, lr, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "ResourceSparseApplyAdagradV2")
  self.execute("ResourceSparseApplyAdagradV2", [var, accum, lr, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, update_slots: update_slots, name: name)
end

.resource_sparse_apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyCenteredRMSProp") ⇒ Object 



3435
3436
3437
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3435

def self.resource_sparse_apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyCenteredRMSProp")
  self.execute("ResourceSparseApplyCenteredRMSProp", [var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_ftrl(var, accum, linear, grad, indices, lr, l1, l2, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyFtrl") ⇒ Object 



3439
3440
3441
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3439

def self.resource_sparse_apply_ftrl(var, accum, linear, grad, indices, lr, l1, l2, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyFtrl")
  self.execute("ResourceSparseApplyFtrl", [var, accum, linear, grad, indices, lr, l1, l2, lr_power], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_ftrl_v2(var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyFtrlV2") ⇒ Object 



3443
3444
3445
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3443

def self.resource_sparse_apply_ftrl_v2(var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyFtrlV2")
  self.execute("ResourceSparseApplyFtrlV2", [var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_keras_momentum(var, accum, lr, grad, indices, momentum, typeT: nil, tindices: nil, use_locking: false, use_nesterov: false, name: "ResourceSparseApplyKerasMomentum") ⇒ Object 



3447
3448
3449
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3447

def self.resource_sparse_apply_keras_momentum(var, accum, lr, grad, indices, momentum, typeT: nil, tindices: nil, use_locking: false, use_nesterov: false, name: "ResourceSparseApplyKerasMomentum")
  self.execute("ResourceSparseApplyKerasMomentum", [var, accum, lr, grad, indices, momentum], T: typeT, Tindices: tindices, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.resource_sparse_apply_momentum(var, accum, lr, grad, indices, momentum, typeT: nil, tindices: nil, use_locking: false, use_nesterov: false, name: "ResourceSparseApplyMomentum") ⇒ Object 



3451
3452
3453
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3451

def self.resource_sparse_apply_momentum(var, accum, lr, grad, indices, momentum, typeT: nil, tindices: nil, use_locking: false, use_nesterov: false, name: "ResourceSparseApplyMomentum")
  self.execute("ResourceSparseApplyMomentum", [var, accum, lr, grad, indices, momentum], T: typeT, Tindices: tindices, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.resource_sparse_apply_proximal_adagrad(var, accum, lr, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyProximalAdagrad") ⇒ Object 



3455
3456
3457
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3455

def self.resource_sparse_apply_proximal_adagrad(var, accum, lr, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyProximalAdagrad")
  self.execute("ResourceSparseApplyProximalAdagrad", [var, accum, lr, l1, l2, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_proximal_gradient_descent(var, alpha, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyProximalGradientDescent") ⇒ Object 



3459
3460
3461
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3459

def self.resource_sparse_apply_proximal_gradient_descent(var, alpha, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyProximalGradientDescent")
  self.execute("ResourceSparseApplyProximalGradientDescent", [var, alpha, l1, l2, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_sparse_apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyRMSProp") ⇒ Object 



3463
3464
3465
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3463

def self.resource_sparse_apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "ResourceSparseApplyRMSProp")
  self.execute("ResourceSparseApplyRMSProp", [var, ms, mom, lr, rho, momentum, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.resource_strided_slice_assign(ref, start, stop, strides, value, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "ResourceStridedSliceAssign") ⇒ Object 



3467
3468
3469
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3467

def self.resource_strided_slice_assign(ref, start, stop, strides, value, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "ResourceStridedSliceAssign")
  self.execute("ResourceStridedSliceAssign", [ref, start, stop, strides, value], T: typeT, Index: index, begin_mask: begin_mask, end_mask: end_mask, ellipsis_mask: ellipsis_mask, new_axis_mask: new_axis_mask, shrink_axis_mask: shrink_axis_mask, name: name)
end

.restore(file_pattern, tensor_name, dt: nil, preferred_shard: -1,, name: "Restore") ⇒ Object 



3471
3472
3473
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3471

def self.restore(file_pattern, tensor_name, dt: nil, preferred_shard: -1, name: "Restore")
  self.execute("Restore", [file_pattern, tensor_name], dt: dt, preferred_shard: preferred_shard, name: name)
end

.restore_slice(file_pattern, tensor_name, shape_and_slice, dt: nil, preferred_shard: -1,, name: "RestoreSlice") ⇒ Object 



3475
3476
3477
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3475

def self.restore_slice(file_pattern, tensor_name, shape_and_slice, dt: nil, preferred_shard: -1, name: "RestoreSlice")
  self.execute("RestoreSlice", [file_pattern, tensor_name, shape_and_slice], dt: dt, preferred_shard: preferred_shard, name: name)
end

.restore_v2(prefix, tensor_names, shape_and_slices, dtypes: nil, name: "RestoreV2") ⇒ Object 



3479
3480
3481
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3479

def self.restore_v2(prefix, tensor_names, shape_and_slices, dtypes: nil, name: "RestoreV2")
  self.execute("RestoreV2", [prefix, tensor_names, shape_and_slices], dtypes: dtypes, name: name)
end

.retrieve_tpu_embedding_adadelta_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdadeltaParameters") ⇒ Object 



3491
3492
3493
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3491

def self.retrieve_tpu_embedding_adadelta_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdadeltaParameters")
  self.execute("RetrieveTPUEmbeddingAdadeltaParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_adadelta_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug") ⇒ Object 



3495
3496
3497
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3495

def self.retrieve_tpu_embedding_adadelta_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_adagrad_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdagradParameters") ⇒ Object 



3499
3500
3501
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3499

def self.retrieve_tpu_embedding_adagrad_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdagradParameters")
  self.execute("RetrieveTPUEmbeddingAdagradParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_adagrad_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdagradParametersGradAccumDebug") ⇒ Object 



3503
3504
3505
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3503

def self.retrieve_tpu_embedding_adagrad_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingAdagradParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingAdagradParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_adam_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingADAMParameters") ⇒ Object 



3483
3484
3485
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3483

def self.retrieve_tpu_embedding_adam_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingADAMParameters")
  self.execute("RetrieveTPUEmbeddingADAMParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_adam_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingADAMParametersGradAccumDebug") ⇒ Object 



3487
3488
3489
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3487

def self.retrieve_tpu_embedding_adam_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingADAMParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingADAMParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_centered_rms_prop_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingCenteredRMSPropParameters") ⇒ Object 



3507
3508
3509
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3507

def self.retrieve_tpu_embedding_centered_rms_prop_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingCenteredRMSPropParameters")
  self.execute("RetrieveTPUEmbeddingCenteredRMSPropParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_ftrl_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingFTRLParameters") ⇒ Object 



3511
3512
3513
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3511

def self.retrieve_tpu_embedding_ftrl_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingFTRLParameters")
  self.execute("RetrieveTPUEmbeddingFTRLParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_ftrl_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingFTRLParametersGradAccumDebug") ⇒ Object 



3515
3516
3517
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3515

def self.retrieve_tpu_embedding_ftrl_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingFTRLParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingFTRLParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_mdl_adagrad_light_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingMDLAdagradLightParameters") ⇒ Object 



3519
3520
3521
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3519

def self.retrieve_tpu_embedding_mdl_adagrad_light_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingMDLAdagradLightParameters")
  self.execute("RetrieveTPUEmbeddingMDLAdagradLightParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_momentum_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingMomentumParameters") ⇒ Object 



3523
3524
3525
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3523

def self.retrieve_tpu_embedding_momentum_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingMomentumParameters")
  self.execute("RetrieveTPUEmbeddingMomentumParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_momentum_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingMomentumParametersGradAccumDebug") ⇒ Object 



3527
3528
3529
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3527

def self.retrieve_tpu_embedding_momentum_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingMomentumParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingMomentumParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_proximal_adagrad_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingProximalAdagradParameters") ⇒ Object 



3531
3532
3533
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3531

def self.retrieve_tpu_embedding_proximal_adagrad_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingProximalAdagradParameters")
  self.execute("RetrieveTPUEmbeddingProximalAdagradParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_proximal_adagrad_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug") ⇒ Object 



3535
3536
3537
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3535

def self.retrieve_tpu_embedding_proximal_adagrad_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_rms_prop_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingRMSPropParameters") ⇒ Object 



3539
3540
3541
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3539

def self.retrieve_tpu_embedding_rms_prop_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingRMSPropParameters")
  self.execute("RetrieveTPUEmbeddingRMSPropParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_rms_prop_parameters_grad_accum_debug(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug") ⇒ Object 



3543
3544
3545
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3543

def self.retrieve_tpu_embedding_rms_prop_parameters_grad_accum_debug(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug")
  self.execute("RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.retrieve_tpu_embedding_stochastic_gradient_descent_parameters(table_id: -1,, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingStochasticGradientDescentParameters") ⇒ Object 



3547
3548
3549
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3547

def self.retrieve_tpu_embedding_stochastic_gradient_descent_parameters(table_id: -1, table_name: "", num_shards: nil, shard_id: nil, config: "", name: "RetrieveTPUEmbeddingStochasticGradientDescentParameters")
  self.execute("RetrieveTPUEmbeddingStochasticGradientDescentParameters", [], table_id: table_id, table_name: table_name, num_shards: num_shards, shard_id: shard_id, config: config, name: name)
end

.reverse(tensor, dims, typeT: nil, name: "Reverse") ⇒ Object 



3551
3552
3553
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3551

def self.reverse(tensor, dims, typeT: nil, name: "Reverse")
  self.execute("Reverse", [tensor, dims], T: typeT, name: name)
end

.reverse_sequence(input, seq_lengths, seq_dim: nil, batch_dim: 0, typeT: nil, tlen: :int64, name: "ReverseSequence") ⇒ Object 



3555
3556
3557
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3555

def self.reverse_sequence(input, seq_lengths, seq_dim: nil, batch_dim: 0, typeT: nil, tlen: :int64, name: "ReverseSequence")
  self.execute("ReverseSequence", [input, seq_lengths], seq_dim: seq_dim, batch_dim: batch_dim, T: typeT, Tlen: tlen, name: name)
end

.reverse_v2(tensor, axis, tidx: :int32, typeT: nil, name: "ReverseV2") ⇒ Object 



3559
3560
3561
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3559

def self.reverse_v2(tensor, axis, tidx: :int32, typeT: nil, name: "ReverseV2")
  self.execute("ReverseV2", [tensor, axis], Tidx: tidx, T: typeT, name: name)
end

.rfft(input, fft_length, treal: :float, tcomplex: :complex64, name: "RFFT") ⇒ Object 



2959
2960
2961
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2959

def self.rfft(input, fft_length, treal: :float, tcomplex: :complex64, name: "RFFT")
  self.execute("RFFT", [input, fft_length], Treal: treal, Tcomplex: tcomplex, name: name)
end

.rfft2_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "RFFT2D") ⇒ Object 



2963
2964
2965
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2963

def self.rfft2_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "RFFT2D")
  self.execute("RFFT2D", [input, fft_length], Treal: treal, Tcomplex: tcomplex, name: name)
end

.rfft3_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "RFFT3D") ⇒ Object 



2967
2968
2969
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2967

def self.rfft3_d(input, fft_length, treal: :float, tcomplex: :complex64, name: "RFFT3D")
  self.execute("RFFT3D", [input, fft_length], Treal: treal, Tcomplex: tcomplex, name: name)
end

.rgb_to_hsv(images, typeT: :float, name: "RGBToHSV") ⇒ Object 



2971
2972
2973
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 2971

def self.rgb_to_hsv(images, typeT: :float, name: "RGBToHSV")
  self.execute("RGBToHSV", [images], T: typeT, name: name)
end

.right_shift(x, y, typeT: nil, name: "RightShift") ⇒ Object 



3563
3564
3565
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3563

def self.right_shift(x, y, typeT: nil, name: "RightShift")
  self.execute("RightShift", [x, y], T: typeT, name: name)
end

.rint(x, typeT: nil, name: "Rint") ⇒ Object 



3567
3568
3569
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3567

def self.rint(x, typeT: nil, name: "Rint")
  self.execute("Rint", [x], T: typeT, name: name)
end

.rng_skip(resource, algorithm, delta, name: "RngSkip") ⇒ Object 



3571
3572
3573
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3571

def self.rng_skip(resource, algorithm, delta, name: "RngSkip")
  self.execute("RngSkip", [resource, algorithm, delta], name: name)
end

.roll(input, shift, axis, typeT: nil, tshift: nil, taxis: nil, name: "Roll") ⇒ Object 



3575
3576
3577
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3575

def self.roll(input, shift, axis, typeT: nil, tshift: nil, taxis: nil, name: "Roll")
  self.execute("Roll", [input, shift, axis], T: typeT, Tshift: tshift, Taxis: taxis, name: name)
end

.round(x, typeT: nil, name: "Round") ⇒ Object 



3579
3580
3581
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3579

def self.round(x, typeT: nil, name: "Round")
  self.execute("Round", [x], T: typeT, name: name)
end

.rpc(address, method, request, protocol: "", fail_fast: true, timeout_in_ms: 0, name: "Rpc") ⇒ Object 



3583
3584
3585
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3583

def self.rpc(address, method, request, protocol: "", fail_fast: true, timeout_in_ms: 0, name: "Rpc")
  self.execute("Rpc", [address, method, request], protocol: protocol, fail_fast: fail_fast, timeout_in_ms: timeout_in_ms, name: name)
end

.rsqrt(x, typeT: nil, name: "Rsqrt") ⇒ Object 



3587
3588
3589
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3587

def self.rsqrt(x, typeT: nil, name: "Rsqrt")
  self.execute("Rsqrt", [x], T: typeT, name: name)
end

.rsqrt_grad(y, dy, typeT: nil, name: "RsqrtGrad") ⇒ Object 



3591
3592
3593
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3591

def self.rsqrt_grad(y, dy, typeT: nil, name: "RsqrtGrad")
  self.execute("RsqrtGrad", [y, dy], T: typeT, name: name)
end

.sample_distorted_bounding_box(image_size, bounding_boxes, typeT: nil, seed: 0, seed2: 0, min_object_covered: 0.10000000149011612, aspect_ratio_range: [], area_range: [], max_attempts: 100, use_image_if_no_bounding_boxes: false, name: "SampleDistortedBoundingBox") ⇒ Object 



3595
3596
3597
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3595

def self.sample_distorted_bounding_box(image_size, bounding_boxes, typeT: nil, seed: 0, seed2: 0, min_object_covered: 0.10000000149011612, aspect_ratio_range: [], area_range: [], max_attempts: 100, use_image_if_no_bounding_boxes: false, name: "SampleDistortedBoundingBox")
  self.execute("SampleDistortedBoundingBox", [image_size, bounding_boxes], T: typeT, seed: seed, seed2: seed2, min_object_covered: min_object_covered, aspect_ratio_range: aspect_ratio_range, area_range: area_range, max_attempts: max_attempts, use_image_if_no_bounding_boxes: use_image_if_no_bounding_boxes, name: name)
end

.sample_distorted_bounding_box_v2(image_size, bounding_boxes, min_object_covered, typeT: nil, seed: 0, seed2: 0, aspect_ratio_range: [], area_range: [], max_attempts: 100, use_image_if_no_bounding_boxes: false, name: "SampleDistortedBoundingBoxV2") ⇒ Object 



3599
3600
3601
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3599

def self.sample_distorted_bounding_box_v2(image_size, bounding_boxes, min_object_covered, typeT: nil, seed: 0, seed2: 0, aspect_ratio_range: [], area_range: [], max_attempts: 100, use_image_if_no_bounding_boxes: false, name: "SampleDistortedBoundingBoxV2")
  self.execute("SampleDistortedBoundingBoxV2", [image_size, bounding_boxes, min_object_covered], T: typeT, seed: seed, seed2: seed2, aspect_ratio_range: aspect_ratio_range, area_range: area_range, max_attempts: max_attempts, use_image_if_no_bounding_boxes: use_image_if_no_bounding_boxes, name: name)
end

.sampling_dataset(input_dataset, rate, seed, seed2, output_types: nil, output_shapes: nil, name: "SamplingDataset") ⇒ Object 



3603
3604
3605
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3603

def self.sampling_dataset(input_dataset, rate, seed, seed2, output_types: nil, output_shapes: nil, name: "SamplingDataset")
  self.execute("SamplingDataset", [input_dataset, rate, seed, seed2], output_types: output_types, output_shapes: output_shapes, name: name)
end

.save(filename, tensor_names, data, typeT: nil, name: "Save") ⇒ Object 



3607
3608
3609
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3607

def self.save(filename, tensor_names, data, typeT: nil, name: "Save")
  self.execute("Save", [filename, tensor_names, data], T: typeT, name: name)
end

.save_slices(filename, tensor_names, shapes_and_slices, data, typeT: nil, name: "SaveSlices") ⇒ Object 



3611
3612
3613
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3611

def self.save_slices(filename, tensor_names, shapes_and_slices, data, typeT: nil, name: "SaveSlices")
  self.execute("SaveSlices", [filename, tensor_names, shapes_and_slices, data], T: typeT, name: name)
end

.save_v2(prefix, tensor_names, shape_and_slices, tensors, dtypes: nil, name: "SaveV2") ⇒ Object 



3615
3616
3617
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3615

def self.save_v2(prefix, tensor_names, shape_and_slices, tensors, dtypes: nil, name: "SaveV2")
  self.execute("SaveV2", [prefix, tensor_names, shape_and_slices, tensors], dtypes: dtypes, name: name)
end

.scalar_summary(tags, values, typeT: nil, name: "ScalarSummary") ⇒ Object 



3619
3620
3621
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3619

def self.scalar_summary(tags, values, typeT: nil, name: "ScalarSummary")
  self.execute("ScalarSummary", [tags, values], T: typeT, name: name)
end

.scale_and_translate(images, size, scale, translation, typeT: nil, kernel_type: "lanczos3", antialias: true, name: "ScaleAndTranslate") ⇒ Object 



3623
3624
3625
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3623

def self.scale_and_translate(images, size, scale, translation, typeT: nil, kernel_type: "lanczos3", antialias: true, name: "ScaleAndTranslate")
  self.execute("ScaleAndTranslate", [images, size, scale, translation], T: typeT, kernel_type: kernel_type, antialias: antialias, name: name)
end

.scale_and_translate_grad(grads, original_image, scale, translation, typeT: nil, kernel_type: "lanczos3", antialias: true, name: "ScaleAndTranslateGrad") ⇒ Object 



3627
3628
3629
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3627

def self.scale_and_translate_grad(grads, original_image, scale, translation, typeT: nil, kernel_type: "lanczos3", antialias: true, name: "ScaleAndTranslateGrad")
  self.execute("ScaleAndTranslateGrad", [grads, original_image, scale, translation], T: typeT, kernel_type: kernel_type, antialias: antialias, name: name)
end

.scan_dataset(input_dataset, initial_state, other_arguments, f: nil, tstate: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, use_default_device: true, name: "ScanDataset") ⇒ Object 



3631
3632
3633
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3631

def self.scan_dataset(input_dataset, initial_state, other_arguments, f: nil, tstate: nil, targuments: nil, output_types: nil, output_shapes: nil, preserve_cardinality: false, use_default_device: true, name: "ScanDataset")
  self.execute("ScanDataset", [input_dataset, initial_state, other_arguments], f: f, Tstate: tstate, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, preserve_cardinality: preserve_cardinality, use_default_device: use_default_device, name: name)
end

.scatter_add(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterAdd") ⇒ Object 



3635
3636
3637
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3635

def self.scatter_add(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterAdd")
  self.execute("ScatterAdd", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_div(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterDiv") ⇒ Object 



3639
3640
3641
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3639

def self.scatter_div(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterDiv")
  self.execute("ScatterDiv", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_max(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterMax") ⇒ Object 



3643
3644
3645
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3643

def self.scatter_max(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterMax")
  self.execute("ScatterMax", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_min(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterMin") ⇒ Object 



3647
3648
3649
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3647

def self.scatter_min(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterMin")
  self.execute("ScatterMin", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_mul(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterMul") ⇒ Object 



3651
3652
3653
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3651

def self.scatter_mul(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterMul")
  self.execute("ScatterMul", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_nd(indices, updates, shape, typeT: nil, tindices: nil, name: "ScatterNd") ⇒ Object 



3655
3656
3657
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3655

def self.scatter_nd(indices, updates, shape, typeT: nil, tindices: nil, name: "ScatterNd")
  self.execute("ScatterNd", [indices, updates, shape], T: typeT, Tindices: tindices, name: name)
end

.scatter_nd_add(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterNdAdd") ⇒ Object 



3659
3660
3661
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3659

def self.scatter_nd_add(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterNdAdd")
  self.execute("ScatterNdAdd", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_nd_non_aliasing_add(input, indices, updates, typeT: nil, tindices: nil, name: "ScatterNdNonAliasingAdd") ⇒ Object 



3663
3664
3665
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3663

def self.scatter_nd_non_aliasing_add(input, indices, updates, typeT: nil, tindices: nil, name: "ScatterNdNonAliasingAdd")
  self.execute("ScatterNdNonAliasingAdd", [input, indices, updates], T: typeT, Tindices: tindices, name: name)
end

.scatter_nd_sub(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterNdSub") ⇒ Object 



3667
3668
3669
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3667

def self.scatter_nd_sub(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterNdSub")
  self.execute("ScatterNdSub", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_nd_update(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ScatterNdUpdate") ⇒ Object 



3671
3672
3673
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3671

def self.scatter_nd_update(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ScatterNdUpdate")
  self.execute("ScatterNdUpdate", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_sub(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterSub") ⇒ Object 



3675
3676
3677
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3675

def self.scatter_sub(ref, indices, updates, typeT: nil, tindices: nil, use_locking: false, name: "ScatterSub")
  self.execute("ScatterSub", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.scatter_update(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ScatterUpdate") ⇒ Object 



3679
3680
3681
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3679

def self.scatter_update(ref, indices, updates, typeT: nil, tindices: nil, use_locking: true, name: "ScatterUpdate")
  self.execute("ScatterUpdate", [ref, indices, updates], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sdca_fprint(input, name: "SdcaFprint") ⇒ Object 



3683
3684
3685
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3683

def self.sdca_fprint(input, name: "SdcaFprint")
  self.execute("SdcaFprint", [input], name: name)
end

.sdca_optimizer(sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data, loss_type: nil, adaptative: false, num_sparse_features: nil, num_sparse_features_with_values: nil, num_dense_features: nil, l1: nil, l2: nil, num_loss_partitions: nil, num_inner_iterations: nil, name: "SdcaOptimizer") ⇒ Object 



3687
3688
3689
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3687

def self.sdca_optimizer(sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data, loss_type: nil, adaptative: false, num_sparse_features: nil, num_sparse_features_with_values: nil, num_dense_features: nil, l1: nil, l2: nil, num_loss_partitions: nil, num_inner_iterations: nil, name: "SdcaOptimizer")
  self.execute("SdcaOptimizer", [sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data], loss_type: loss_type, adaptative: adaptative, num_sparse_features: num_sparse_features, num_sparse_features_with_values: num_sparse_features_with_values, num_dense_features: num_dense_features, l1: l1, l2: l2, num_loss_partitions: num_loss_partitions, num_inner_iterations: num_inner_iterations, name: name)
end

.sdca_optimizer_v2(sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data, loss_type: nil, adaptive: false, num_sparse_features: nil, num_sparse_features_with_values: nil, num_dense_features: nil, l1: nil, l2: nil, num_loss_partitions: nil, num_inner_iterations: nil, name: "SdcaOptimizerV2") ⇒ Object 



3691
3692
3693
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3691

def self.sdca_optimizer_v2(sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data, loss_type: nil, adaptive: false, num_sparse_features: nil, num_sparse_features_with_values: nil, num_dense_features: nil, l1: nil, l2: nil, num_loss_partitions: nil, num_inner_iterations: nil, name: "SdcaOptimizerV2")
  self.execute("SdcaOptimizerV2", [sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data], loss_type: loss_type, adaptive: adaptive, num_sparse_features: num_sparse_features, num_sparse_features_with_values: num_sparse_features_with_values, num_dense_features: num_dense_features, l1: l1, l2: l2, num_loss_partitions: num_loss_partitions, num_inner_iterations: num_inner_iterations, name: name)
end

.sdca_shrink_l1(weights, num_features: nil, l1: nil, l2: nil, name: "SdcaShrinkL1") ⇒ Object 



3695
3696
3697
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3695

def self.sdca_shrink_l1(weights, num_features: nil, l1: nil, l2: nil, name: "SdcaShrinkL1")
  self.execute("SdcaShrinkL1", [weights], num_features: num_features, l1: l1, l2: l2, name: name)
end

.segment_max(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentMax") ⇒ Object 



3699
3700
3701
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3699

def self.segment_max(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentMax")
  self.execute("SegmentMax", [data, segment_ids], T: typeT, Tindices: tindices, name: name)
end

.segment_mean(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentMean") ⇒ Object 



3703
3704
3705
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3703

def self.segment_mean(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentMean")
  self.execute("SegmentMean", [data, segment_ids], T: typeT, Tindices: tindices, name: name)
end

.segment_min(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentMin") ⇒ Object 



3707
3708
3709
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3707

def self.segment_min(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentMin")
  self.execute("SegmentMin", [data, segment_ids], T: typeT, Tindices: tindices, name: name)
end

.segment_prod(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentProd") ⇒ Object 



3711
3712
3713
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3711

def self.segment_prod(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentProd")
  self.execute("SegmentProd", [data, segment_ids], T: typeT, Tindices: tindices, name: name)
end

.segment_sum(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentSum") ⇒ Object 



3715
3716
3717
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3715

def self.segment_sum(data, segment_ids, typeT: nil, tindices: nil, name: "SegmentSum")
  self.execute("SegmentSum", [data, segment_ids], T: typeT, Tindices: tindices, name: name)
end

.select(condition, t, e, typeT: nil, name: "Select") ⇒ Object 



3719
3720
3721
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3719

def self.select(condition, t, e, typeT: nil, name: "Select")
  self.execute("Select", [condition, t, e], T: typeT, name: name)
end

.select_v2(condition, t, e, typeT: nil, name: "SelectV2") ⇒ Object 



3723
3724
3725
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3723

def self.select_v2(condition, t, e, typeT: nil, name: "SelectV2")
  self.execute("SelectV2", [condition, t, e], T: typeT, name: name)
end

.self_adjoint_eig(input, typeT: nil, name: "SelfAdjointEig") ⇒ Object 



3727
3728
3729
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3727

def self.self_adjoint_eig(input, typeT: nil, name: "SelfAdjointEig")
  self.execute("SelfAdjointEig", [input], T: typeT, name: name)
end

.self_adjoint_eig_v2(input, compute_v: true, typeT: nil, name: "SelfAdjointEigV2") ⇒ Object 



3731
3732
3733
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3731

def self.self_adjoint_eig_v2(input, compute_v: true, typeT: nil, name: "SelfAdjointEigV2")
  self.execute("SelfAdjointEigV2", [input], compute_v: compute_v, T: typeT, name: name)
end

.selu(features, typeT: nil, name: "Selu") ⇒ Object 



3735
3736
3737
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3735

def self.selu(features, typeT: nil, name: "Selu")
  self.execute("Selu", [features], T: typeT, name: name)
end

.selu_grad(gradients, outputs, typeT: nil, name: "SeluGrad") ⇒ Object 



3739
3740
3741
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3739

def self.selu_grad(gradients, outputs, typeT: nil, name: "SeluGrad")
  self.execute("SeluGrad", [gradients, outputs], T: typeT, name: name)
end

.send(tensor, typeT: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "Send") ⇒ Object 



3743
3744
3745
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3743

def self.send(tensor, typeT: nil, tensor_name: "", send_device: "", send_device_incarnation: nil, recv_device: "", client_terminated: false, name: "Send")
  self.execute("Send", [tensor], T: typeT, tensor_name: tensor_name, send_device: send_device, send_device_incarnation: send_device_incarnation, recv_device: recv_device, client_terminated: client_terminated, name: name)
end

.send_tpu_embedding_gradients(inputs, learning_rates, n: nil, nn: 0, config: "", name: "SendTPUEmbeddingGradients") ⇒ Object 



3747
3748
3749
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3747

def self.send_tpu_embedding_gradients(inputs, learning_rates, n: nil, nn: 0, config: "", name: "SendTPUEmbeddingGradients")
  self.execute("SendTPUEmbeddingGradients", [inputs, learning_rates], N: n, NN: nn, config: config, name: name)
end

.serialize_iterator(resource_handle, name: "SerializeIterator") ⇒ Object 



3751
3752
3753
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3751

def self.serialize_iterator(resource_handle, name: "SerializeIterator")
  self.execute("SerializeIterator", [resource_handle], name: name)
end

.serialize_many_sparse(sparse_indices, sparse_values, sparse_shape, typeT: nil, out_type: :string, name: "SerializeManySparse") ⇒ Object 



3755
3756
3757
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3755

def self.serialize_many_sparse(sparse_indices, sparse_values, sparse_shape, typeT: nil, out_type: :string, name: "SerializeManySparse")
  self.execute("SerializeManySparse", [sparse_indices, sparse_values, sparse_shape], T: typeT, out_type: out_type, name: name)
end

.serialize_sparse(sparse_indices, sparse_values, sparse_shape, typeT: nil, out_type: :string, name: "SerializeSparse") ⇒ Object 



3759
3760
3761
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3759

def self.serialize_sparse(sparse_indices, sparse_values, sparse_shape, typeT: nil, out_type: :string, name: "SerializeSparse")
  self.execute("SerializeSparse", [sparse_indices, sparse_values, sparse_shape], T: typeT, out_type: out_type, name: name)
end

.serialize_tensor(tensor, typeT: nil, name: "SerializeTensor") ⇒ Object 



3763
3764
3765
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3763

def self.serialize_tensor(tensor, typeT: nil, name: "SerializeTensor")
  self.execute("SerializeTensor", [tensor], T: typeT, name: name)
end

.set_size(set_indices, set_values, set_shape, validate_indices: true, typeT: nil, name: "SetSize") ⇒ Object 



3767
3768
3769
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3767

def self.set_size(set_indices, set_values, set_shape, validate_indices: true, typeT: nil, name: "SetSize")
  self.execute("SetSize", [set_indices, set_values, set_shape], validate_indices: validate_indices, T: typeT, name: name)
end

.set_stats_aggregator_dataset(input_dataset, stats_aggregator, tag, counter_prefix, output_types: nil, output_shapes: nil, name: "SetStatsAggregatorDataset") ⇒ Object 



3771
3772
3773
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3771

def self.set_stats_aggregator_dataset(input_dataset, stats_aggregator, tag, counter_prefix, output_types: nil, output_shapes: nil, name: "SetStatsAggregatorDataset")
  self.execute("SetStatsAggregatorDataset", [input_dataset, stats_aggregator, tag, counter_prefix], output_types: output_types, output_shapes: output_shapes, name: name)
end

.shape(input, typeT: nil, out_type: :int32, name: "Shape") ⇒ Object 



3775
3776
3777
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3775

def self.shape(input, typeT: nil, out_type: :int32, name: "Shape")
  self.execute("Shape", [input], T: typeT, out_type: out_type, name: name)
end

.shape_n(input, n: nil, typeT: nil, out_type: :int32, name: "ShapeN") ⇒ Object 



3779
3780
3781
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3779

def self.shape_n(input, n: nil, typeT: nil, out_type: :int32, name: "ShapeN")
  self.execute("ShapeN", [input], N: n, T: typeT, out_type: out_type, name: name)
end

.shard_dataset(input_dataset, num_shards, index, require_non_empty: false, output_types: nil, output_shapes: nil, name: "ShardDataset") ⇒ Object 



3783
3784
3785
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3783

def self.shard_dataset(input_dataset, num_shards, index, require_non_empty: false, output_types: nil, output_shapes: nil, name: "ShardDataset")
  self.execute("ShardDataset", [input_dataset, num_shards, index], require_non_empty: require_non_empty, output_types: output_types, output_shapes: output_shapes, name: name)
end

.sharded_filename(basename, shard, num_shards, name: "ShardedFilename") ⇒ Object 



3787
3788
3789
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3787

def self.sharded_filename(basename, shard, num_shards, name: "ShardedFilename")
  self.execute("ShardedFilename", [basename, shard, num_shards], name: name)
end

.sharded_filespec(basename, num_shards, name: "ShardedFilespec") ⇒ Object 



3791
3792
3793
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3791

def self.sharded_filespec(basename, num_shards, name: "ShardedFilespec")
  self.execute("ShardedFilespec", [basename, num_shards], name: name)
end

.shuffle_and_repeat_dataset(input_dataset, buffer_size, seed, seed2, count, output_types: nil, output_shapes: nil, name: "ShuffleAndRepeatDataset") ⇒ Object 



3795
3796
3797
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3795

def self.shuffle_and_repeat_dataset(input_dataset, buffer_size, seed, seed2, count, output_types: nil, output_shapes: nil, name: "ShuffleAndRepeatDataset")
  self.execute("ShuffleAndRepeatDataset", [input_dataset, buffer_size, seed, seed2, count], output_types: output_types, output_shapes: output_shapes, name: name)
end

.shuffle_dataset(input_dataset, buffer_size, seed, seed2, reshuffle_each_iteration: true, output_types: nil, output_shapes: nil, name: "ShuffleDataset") ⇒ Object 



3799
3800
3801
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3799

def self.shuffle_dataset(input_dataset, buffer_size, seed, seed2, reshuffle_each_iteration: true, output_types: nil, output_shapes: nil, name: "ShuffleDataset")
  self.execute("ShuffleDataset", [input_dataset, buffer_size, seed, seed2], reshuffle_each_iteration: reshuffle_each_iteration, output_types: output_types, output_shapes: output_shapes, name: name)
end

.shuffle_dataset_v2(input_dataset, buffer_size, seed_generator, output_types: nil, output_shapes: nil, name: "ShuffleDatasetV2") ⇒ Object 



3803
3804
3805
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3803

def self.shuffle_dataset_v2(input_dataset, buffer_size, seed_generator, output_types: nil, output_shapes: nil, name: "ShuffleDatasetV2")
  self.execute("ShuffleDatasetV2", [input_dataset, buffer_size, seed_generator], output_types: output_types, output_shapes: output_shapes, name: name)
end

.shutdown_distributed_tpu(name: "ShutdownDistributedTPU") ⇒ Object 



3807
3808
3809
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3807

def self.shutdown_distributed_tpu(name: "ShutdownDistributedTPU")
  self.execute("ShutdownDistributedTPU", [], name: name)
end

.sigmoid(x, typeT: nil, name: "Sigmoid") ⇒ Object 



3811
3812
3813
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3811

def self.sigmoid(x, typeT: nil, name: "Sigmoid")
  self.execute("Sigmoid", [x], T: typeT, name: name)
end

.sigmoid_grad(y, dy, typeT: nil, name: "SigmoidGrad") ⇒ Object 



3815
3816
3817
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3815

def self.sigmoid_grad(y, dy, typeT: nil, name: "SigmoidGrad")
  self.execute("SigmoidGrad", [y, dy], T: typeT, name: name)
end

.sign(x, typeT: nil, name: "Sign") ⇒ Object 



3819
3820
3821
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3819

def self.sign(x, typeT: nil, name: "Sign")
  self.execute("Sign", [x], T: typeT, name: name)
end

.sin(x, typeT: nil, name: "Sin") ⇒ Object 



3823
3824
3825
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3823

def self.sin(x, typeT: nil, name: "Sin")
  self.execute("Sin", [x], T: typeT, name: name)
end

.sinh(x, typeT: nil, name: "Sinh") ⇒ Object 



3827
3828
3829
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3827

def self.sinh(x, typeT: nil, name: "Sinh")
  self.execute("Sinh", [x], T: typeT, name: name)
end

.size(input, typeT: nil, out_type: :int32, name: "Size") ⇒ Object 



3831
3832
3833
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3831

def self.size(input, typeT: nil, out_type: :int32, name: "Size")
  self.execute("Size", [input], T: typeT, out_type: out_type, name: name)
end

.skip_dataset(input_dataset, count, output_types: nil, output_shapes: nil, name: "SkipDataset") ⇒ Object 



3835
3836
3837
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3835

def self.skip_dataset(input_dataset, count, output_types: nil, output_shapes: nil, name: "SkipDataset")
  self.execute("SkipDataset", [input_dataset, count], output_types: output_types, output_shapes: output_shapes, name: name)
end

.skipgram(filename: "", batch_size: nil, window_size: 5, min_count: 5, subsample: 0.0010000000474974513, name: "Skipgram") ⇒ Object 



3839
3840
3841
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3839

def self.skipgram(filename: "", batch_size: nil, window_size: 5, min_count: 5, subsample: 0.0010000000474974513, name: "Skipgram")
  self.execute("Skipgram", [], filename: filename, batch_size: batch_size, window_size: window_size, min_count: min_count, subsample: subsample, name: name)
end

.sleep_dataset(input_dataset, sleep_microseconds, output_types: nil, output_shapes: nil, name: "SleepDataset") ⇒ Object 



3843
3844
3845
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3843

def self.sleep_dataset(input_dataset, sleep_microseconds, output_types: nil, output_shapes: nil, name: "SleepDataset")
  self.execute("SleepDataset", [input_dataset, sleep_microseconds], output_types: output_types, output_shapes: output_shapes, name: name)
end

.slice(input, start, size, typeT: nil, index: nil, name: "Slice") ⇒ Object 



3847
3848
3849
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3847

def self.slice(input, start, size, typeT: nil, index: nil, name: "Slice")
  self.execute("Slice", [input, start, size], T: typeT, Index: index, name: name)
end

.sliding_window_dataset(input_dataset, window_size, window_shift, window_stride, output_types: nil, output_shapes: nil, name: "SlidingWindowDataset") ⇒ Object 



3851
3852
3853
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3851

def self.sliding_window_dataset(input_dataset, window_size, window_shift, window_stride, output_types: nil, output_shapes: nil, name: "SlidingWindowDataset")
  self.execute("SlidingWindowDataset", [input_dataset, window_size, window_shift, window_stride], output_types: output_types, output_shapes: output_shapes, name: name)
end

.snapshot(input, typeT: nil, name: "Snapshot") ⇒ Object 



3855
3856
3857
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3855

def self.snapshot(input, typeT: nil, name: "Snapshot")
  self.execute("Snapshot", [input], T: typeT, name: name)
end

.snapshot_dataset(input_dataset, path, output_types: nil, output_shapes: nil, compression: "", reader_path_prefix: "", writer_path_prefix: "", shard_size_bytes: 10737418240, pending_snapshot_expiry_seconds: 86400, num_reader_threads: 1, reader_buffer_size: 1, num_writer_threads: 1, writer_buffer_size: 1, shuffle_on_read: false, seed: 0, seed2: 0, name: "SnapshotDataset") ⇒ Object 



3859
3860
3861
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3859

def self.snapshot_dataset(input_dataset, path, output_types: nil, output_shapes: nil, compression: "", reader_path_prefix: "", writer_path_prefix: "", shard_size_bytes: 10737418240, pending_snapshot_expiry_seconds: 86400, num_reader_threads: 1, reader_buffer_size: 1, num_writer_threads: 1, writer_buffer_size: 1, shuffle_on_read: false, seed: 0, seed2: 0, name: "SnapshotDataset")
  self.execute("SnapshotDataset", [input_dataset, path], output_types: output_types, output_shapes: output_shapes, compression: compression, reader_path_prefix: reader_path_prefix, writer_path_prefix: writer_path_prefix, shard_size_bytes: shard_size_bytes, pending_snapshot_expiry_seconds: pending_snapshot_expiry_seconds, num_reader_threads: num_reader_threads, reader_buffer_size: reader_buffer_size, num_writer_threads: num_writer_threads, writer_buffer_size: writer_buffer_size, shuffle_on_read: shuffle_on_read, seed: seed, seed2: seed2, name: name)
end

.softmax(logits, typeT: nil, name: "Softmax") ⇒ Object 



3863
3864
3865
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3863

def self.softmax(logits, typeT: nil, name: "Softmax")
  self.execute("Softmax", [logits], T: typeT, name: name)
end

.softmax_cross_entropy_with_logits(features, labels, typeT: nil, name: "SoftmaxCrossEntropyWithLogits") ⇒ Object 



3867
3868
3869
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3867

def self.softmax_cross_entropy_with_logits(features, labels, typeT: nil, name: "SoftmaxCrossEntropyWithLogits")
  self.execute("SoftmaxCrossEntropyWithLogits", [features, labels], T: typeT, name: name)
end

.softplus(features, typeT: nil, name: "Softplus") ⇒ Object 



3871
3872
3873
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3871

def self.softplus(features, typeT: nil, name: "Softplus")
  self.execute("Softplus", [features], T: typeT, name: name)
end

.softplus_grad(gradients, features, typeT: nil, name: "SoftplusGrad") ⇒ Object 



3875
3876
3877
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3875

def self.softplus_grad(gradients, features, typeT: nil, name: "SoftplusGrad")
  self.execute("SoftplusGrad", [gradients, features], T: typeT, name: name)
end

.softsign(features, typeT: nil, name: "Softsign") ⇒ Object 



3879
3880
3881
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3879

def self.softsign(features, typeT: nil, name: "Softsign")
  self.execute("Softsign", [features], T: typeT, name: name)
end

.softsign_grad(gradients, features, typeT: nil, name: "SoftsignGrad") ⇒ Object 



3883
3884
3885
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3883

def self.softsign_grad(gradients, features, typeT: nil, name: "SoftsignGrad")
  self.execute("SoftsignGrad", [gradients, features], T: typeT, name: name)
end

.space_to_batch(input, paddings, typeT: nil, tpaddings: :int32, block_size: nil, name: "SpaceToBatch") ⇒ Object 



3887
3888
3889
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3887

def self.space_to_batch(input, paddings, typeT: nil, tpaddings: :int32, block_size: nil, name: "SpaceToBatch")
  self.execute("SpaceToBatch", [input, paddings], T: typeT, Tpaddings: tpaddings, block_size: block_size, name: name)
end

.space_to_batch_nd(input, block_shape, paddings, typeT: nil, tblock_shape: :int32, tpaddings: :int32, name: "SpaceToBatchND") ⇒ Object 



3891
3892
3893
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3891

def self.space_to_batch_nd(input, block_shape, paddings, typeT: nil, tblock_shape: :int32, tpaddings: :int32, name: "SpaceToBatchND")
  self.execute("SpaceToBatchND", [input, block_shape, paddings], T: typeT, Tblock_shape: tblock_shape, Tpaddings: tpaddings, name: name)
end

.space_to_depth(input, typeT: nil, block_size: nil, data_format: "NHWC", name: "SpaceToDepth") ⇒ Object 



3895
3896
3897
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3895

def self.space_to_depth(input, typeT: nil, block_size: nil, data_format: "NHWC", name: "SpaceToDepth")
  self.execute("SpaceToDepth", [input], T: typeT, block_size: block_size, data_format: data_format, name: name)
end

.sparse_accumulator_apply_gradient(handle, local_step, gradient_indices, gradient_values, gradient_shape, dtype: nil, has_known_shape: nil, name: "SparseAccumulatorApplyGradient") ⇒ Object 



3899
3900
3901
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3899

def self.sparse_accumulator_apply_gradient(handle, local_step, gradient_indices, gradient_values, gradient_shape, dtype: nil, has_known_shape: nil, name: "SparseAccumulatorApplyGradient")
  self.execute("SparseAccumulatorApplyGradient", [handle, local_step, gradient_indices, gradient_values, gradient_shape], dtype: dtype, has_known_shape: has_known_shape, name: name)
end

.sparse_accumulator_take_gradient(handle, num_required, dtype: nil, name: "SparseAccumulatorTakeGradient") ⇒ Object 



3903
3904
3905
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3903

def self.sparse_accumulator_take_gradient(handle, num_required, dtype: nil, name: "SparseAccumulatorTakeGradient")
  self.execute("SparseAccumulatorTakeGradient", [handle, num_required], dtype: dtype, name: name)
end

.sparse_add(a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh, typeT: nil, treal: nil, name: "SparseAdd") ⇒ Object 



3907
3908
3909
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3907

def self.sparse_add(a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh, typeT: nil, treal: nil, name: "SparseAdd")
  self.execute("SparseAdd", [a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh], T: typeT, Treal: treal, name: name)
end

.sparse_add_grad(backprop_val_grad, a_indices, b_indices, sum_indices, typeT: nil, name: "SparseAddGrad") ⇒ Object 



3911
3912
3913
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3911

def self.sparse_add_grad(backprop_val_grad, a_indices, b_indices, sum_indices, typeT: nil, name: "SparseAddGrad")
  self.execute("SparseAddGrad", [backprop_val_grad, a_indices, b_indices, sum_indices], T: typeT, name: name)
end

.sparse_apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyAdadelta") ⇒ Object 



3915
3916
3917
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3915

def self.sparse_apply_adadelta(var, accum, accum_update, lr, rho, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyAdadelta")
  self.execute("SparseApplyAdadelta", [var, accum, accum_update, lr, rho, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_adagrad(var, accum, lr, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "SparseApplyAdagrad") ⇒ Object 



3919
3920
3921
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3919

def self.sparse_apply_adagrad(var, accum, lr, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "SparseApplyAdagrad")
  self.execute("SparseApplyAdagrad", [var, accum, lr, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, update_slots: update_slots, name: name)
end

.sparse_apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyAdagradDA") ⇒ Object 



3923
3924
3925
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3923

def self.sparse_apply_adagrad_da(var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyAdagradDA")
  self.execute("SparseApplyAdagradDA", [var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_adagrad_v2(var, accum, lr, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "SparseApplyAdagradV2") ⇒ Object 



3927
3928
3929
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3927

def self.sparse_apply_adagrad_v2(var, accum, lr, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, update_slots: true, name: "SparseApplyAdagradV2")
  self.execute("SparseApplyAdagradV2", [var, accum, lr, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, update_slots: update_slots, name: name)
end

.sparse_apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyCenteredRMSProp") ⇒ Object 



3931
3932
3933
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3931

def self.sparse_apply_centered_rms_prop(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyCenteredRMSProp")
  self.execute("SparseApplyCenteredRMSProp", [var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_ftrl(var, accum, linear, grad, indices, lr, l1, l2, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyFtrl") ⇒ Object 



3935
3936
3937
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3935

def self.sparse_apply_ftrl(var, accum, linear, grad, indices, lr, l1, l2, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyFtrl")
  self.execute("SparseApplyFtrl", [var, accum, linear, grad, indices, lr, l1, l2, lr_power], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_ftrl_v2(var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyFtrlV2") ⇒ Object 



3939
3940
3941
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3939

def self.sparse_apply_ftrl_v2(var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyFtrlV2")
  self.execute("SparseApplyFtrlV2", [var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_momentum(var, accum, lr, grad, indices, momentum, typeT: nil, tindices: nil, use_locking: false, use_nesterov: false, name: "SparseApplyMomentum") ⇒ Object 



3943
3944
3945
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3943

def self.sparse_apply_momentum(var, accum, lr, grad, indices, momentum, typeT: nil, tindices: nil, use_locking: false, use_nesterov: false, name: "SparseApplyMomentum")
  self.execute("SparseApplyMomentum", [var, accum, lr, grad, indices, momentum], T: typeT, Tindices: tindices, use_locking: use_locking, use_nesterov: use_nesterov, name: name)
end

.sparse_apply_proximal_adagrad(var, accum, lr, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyProximalAdagrad") ⇒ Object 



3947
3948
3949
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3947

def self.sparse_apply_proximal_adagrad(var, accum, lr, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyProximalAdagrad")
  self.execute("SparseApplyProximalAdagrad", [var, accum, lr, l1, l2, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_proximal_gradient_descent(var, alpha, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyProximalGradientDescent") ⇒ Object 



3951
3952
3953
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3951

def self.sparse_apply_proximal_gradient_descent(var, alpha, l1, l2, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyProximalGradientDescent")
  self.execute("SparseApplyProximalGradientDescent", [var, alpha, l1, l2, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyRMSProp") ⇒ Object 



3955
3956
3957
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3955

def self.sparse_apply_rms_prop(var, ms, mom, lr, rho, momentum, epsilon, grad, indices, typeT: nil, tindices: nil, use_locking: false, name: "SparseApplyRMSProp")
  self.execute("SparseApplyRMSProp", [var, ms, mom, lr, rho, momentum, epsilon, grad, indices], T: typeT, Tindices: tindices, use_locking: use_locking, name: name)
end

.sparse_concat(indices, values, shapes, concat_dim: nil, n: nil, typeT: nil, name: "SparseConcat") ⇒ Object 



3959
3960
3961
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3959

def self.sparse_concat(indices, values, shapes, concat_dim: nil, n: nil, typeT: nil, name: "SparseConcat")
  self.execute("SparseConcat", [indices, values, shapes], concat_dim: concat_dim, N: n, T: typeT, name: name)
end

.sparse_conditional_accumulator(dtype: nil, shape: nil, container: "", shared_name: "", reduction_type: "MEAN", name: "SparseConditionalAccumulator") ⇒ Object 



3963
3964
3965
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3963

def self.sparse_conditional_accumulator(dtype: nil, shape: nil, container: "", shared_name: "", reduction_type: "MEAN", name: "SparseConditionalAccumulator")
  self.execute("SparseConditionalAccumulator", [], dtype: dtype, shape: shape, container: container, shared_name: shared_name, reduction_type: reduction_type, name: name)
end

.sparse_cross(indices, values, shapes, dense_inputs, n: nil, hashed_output: nil, num_buckets: nil, hash_key: nil, sparse_types: nil, dense_types: nil, out_type: nil, internal_type: nil, name: "SparseCross") ⇒ Object 



3967
3968
3969
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3967

def self.sparse_cross(indices, values, shapes, dense_inputs, n: nil, hashed_output: nil, num_buckets: nil, hash_key: nil, sparse_types: nil, dense_types: nil, out_type: nil, internal_type: nil, name: "SparseCross")
  self.execute("SparseCross", [indices, values, shapes, dense_inputs], N: n, hashed_output: hashed_output, num_buckets: num_buckets, hash_key: hash_key, sparse_types: sparse_types, dense_types: dense_types, out_type: out_type, internal_type: internal_type, name: name)
end

.sparse_dense_cwise_add(sp_indices, sp_values, sp_shape, dense, typeT: nil, name: "SparseDenseCwiseAdd") ⇒ Object 



3971
3972
3973
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3971

def self.sparse_dense_cwise_add(sp_indices, sp_values, sp_shape, dense, typeT: nil, name: "SparseDenseCwiseAdd")
  self.execute("SparseDenseCwiseAdd", [sp_indices, sp_values, sp_shape, dense], T: typeT, name: name)
end

.sparse_dense_cwise_div(sp_indices, sp_values, sp_shape, dense, typeT: nil, name: "SparseDenseCwiseDiv") ⇒ Object 



3975
3976
3977
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3975

def self.sparse_dense_cwise_div(sp_indices, sp_values, sp_shape, dense, typeT: nil, name: "SparseDenseCwiseDiv")
  self.execute("SparseDenseCwiseDiv", [sp_indices, sp_values, sp_shape, dense], T: typeT, name: name)
end

.sparse_dense_cwise_mul(sp_indices, sp_values, sp_shape, dense, typeT: nil, name: "SparseDenseCwiseMul") ⇒ Object 



3979
3980
3981
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3979

def self.sparse_dense_cwise_mul(sp_indices, sp_values, sp_shape, dense, typeT: nil, name: "SparseDenseCwiseMul")
  self.execute("SparseDenseCwiseMul", [sp_indices, sp_values, sp_shape, dense], T: typeT, name: name)
end

.sparse_fill_empty_rows(indices, values, dense_shape, default_value, typeT: nil, name: "SparseFillEmptyRows") ⇒ Object 



3983
3984
3985
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3983

def self.sparse_fill_empty_rows(indices, values, dense_shape, default_value, typeT: nil, name: "SparseFillEmptyRows")
  self.execute("SparseFillEmptyRows", [indices, values, dense_shape, default_value], T: typeT, name: name)
end

.sparse_fill_empty_rows_grad(reverse_index_map, grad_values, typeT: nil, name: "SparseFillEmptyRowsGrad") ⇒ Object 



3987
3988
3989
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3987

def self.sparse_fill_empty_rows_grad(reverse_index_map, grad_values, typeT: nil, name: "SparseFillEmptyRowsGrad")
  self.execute("SparseFillEmptyRowsGrad", [reverse_index_map, grad_values], T: typeT, name: name)
end

.sparse_mat_mul(a, b, transpose_a: false, transpose_b: false, a_is_sparse: false, b_is_sparse: false, ta: :float, tb: :float, name: "SparseMatMul") ⇒ Object 



3991
3992
3993
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3991

def self.sparse_mat_mul(a, b, transpose_a: false, transpose_b: false, a_is_sparse: false, b_is_sparse: false, ta: :float, tb: :float, name: "SparseMatMul")
  self.execute("SparseMatMul", [a, b], transpose_a: transpose_a, transpose_b: transpose_b, a_is_sparse: a_is_sparse, b_is_sparse: b_is_sparse, Ta: ta, Tb: tb, name: name)
end

.sparse_matrix_add(a, b, alpha, beta, typeT: nil, name: "SparseMatrixAdd") ⇒ Object 



3995
3996
3997
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3995

def self.sparse_matrix_add(a, b, alpha, beta, typeT: nil, name: "SparseMatrixAdd")
  self.execute("SparseMatrixAdd", [a, b, alpha, beta], T: typeT, name: name)
end

.sparse_matrix_mat_mul(a, b, typeT: nil, transpose_a: false, transpose_b: false, adjoint_a: false, adjoint_b: false, transpose_output: false, conjugate_output: false, name: "SparseMatrixMatMul") ⇒ Object 



3999
4000
4001
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 3999

def self.sparse_matrix_mat_mul(a, b, typeT: nil, transpose_a: false, transpose_b: false, adjoint_a: false, adjoint_b: false, transpose_output: false, conjugate_output: false, name: "SparseMatrixMatMul")
  self.execute("SparseMatrixMatMul", [a, b], T: typeT, transpose_a: transpose_a, transpose_b: transpose_b, adjoint_a: adjoint_a, adjoint_b: adjoint_b, transpose_output: transpose_output, conjugate_output: conjugate_output, name: name)
end

.sparse_matrix_mul(a, b, typeT: nil, name: "SparseMatrixMul") ⇒ Object 



4003
4004
4005
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4003

def self.sparse_matrix_mul(a, b, typeT: nil, name: "SparseMatrixMul")
  self.execute("SparseMatrixMul", [a, b], T: typeT, name: name)
end

.sparse_matrix_nnz(sparse_matrix, name: "SparseMatrixNNZ") ⇒ Object 



4007
4008
4009
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4007

def self.sparse_matrix_nnz(sparse_matrix, name: "SparseMatrixNNZ")
  self.execute("SparseMatrixNNZ", [sparse_matrix], name: name)
end

.sparse_matrix_ordering_amd(input, name: "SparseMatrixOrderingAMD") ⇒ Object 



4011
4012
4013
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4011

def self.sparse_matrix_ordering_amd(input, name: "SparseMatrixOrderingAMD")
  self.execute("SparseMatrixOrderingAMD", [input], name: name)
end

.sparse_matrix_softmax(logits, type: nil, name: "SparseMatrixSoftmax") ⇒ Object 



4015
4016
4017
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4015

def self.sparse_matrix_softmax(logits, type: nil, name: "SparseMatrixSoftmax")
  self.execute("SparseMatrixSoftmax", [logits], type: type, name: name)
end

.sparse_matrix_softmax_grad(softmax, grad_softmax, type: nil, name: "SparseMatrixSoftmaxGrad") ⇒ Object 



4019
4020
4021
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4019

def self.sparse_matrix_softmax_grad(softmax, grad_softmax, type: nil, name: "SparseMatrixSoftmaxGrad")
  self.execute("SparseMatrixSoftmaxGrad", [softmax, grad_softmax], type: type, name: name)
end

.sparse_matrix_sparse_cholesky(input, permutation, type: nil, name: "SparseMatrixSparseCholesky") ⇒ Object 



4023
4024
4025
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4023

def self.sparse_matrix_sparse_cholesky(input, permutation, type: nil, name: "SparseMatrixSparseCholesky")
  self.execute("SparseMatrixSparseCholesky", [input, permutation], type: type, name: name)
end

.sparse_matrix_sparse_mat_mul(a, b, type: nil, transpose_a: false, transpose_b: false, adjoint_a: false, adjoint_b: false, name: "SparseMatrixSparseMatMul") ⇒ Object 



4027
4028
4029
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4027

def self.sparse_matrix_sparse_mat_mul(a, b, type: nil, transpose_a: false, transpose_b: false, adjoint_a: false, adjoint_b: false, name: "SparseMatrixSparseMatMul")
  self.execute("SparseMatrixSparseMatMul", [a, b], type: type, transpose_a: transpose_a, transpose_b: transpose_b, adjoint_a: adjoint_a, adjoint_b: adjoint_b, name: name)
end

.sparse_matrix_transpose(input, conjugate: false, type: nil, name: "SparseMatrixTranspose") ⇒ Object 



4031
4032
4033
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4031

def self.sparse_matrix_transpose(input, conjugate: false, type: nil, name: "SparseMatrixTranspose")
  self.execute("SparseMatrixTranspose", [input], conjugate: conjugate, type: type, name: name)
end

.sparse_matrix_zeros(dense_shape, type: nil, name: "SparseMatrixZeros") ⇒ Object 



4035
4036
4037
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4035

def self.sparse_matrix_zeros(dense_shape, type: nil, name: "SparseMatrixZeros")
  self.execute("SparseMatrixZeros", [dense_shape], type: type, name: name)
end

.sparse_reduce_max(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceMax") ⇒ Object 



4039
4040
4041
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4039

def self.sparse_reduce_max(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceMax")
  self.execute("SparseReduceMax", [input_indices, input_values, input_shape, reduction_axes], keep_dims: keep_dims, T: typeT, name: name)
end

.sparse_reduce_max_sparse(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceMaxSparse") ⇒ Object 



4043
4044
4045
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4043

def self.sparse_reduce_max_sparse(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceMaxSparse")
  self.execute("SparseReduceMaxSparse", [input_indices, input_values, input_shape, reduction_axes], keep_dims: keep_dims, T: typeT, name: name)
end

.sparse_reduce_sum(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceSum") ⇒ Object 



4047
4048
4049
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4047

def self.sparse_reduce_sum(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceSum")
  self.execute("SparseReduceSum", [input_indices, input_values, input_shape, reduction_axes], keep_dims: keep_dims, T: typeT, name: name)
end

.sparse_reduce_sum_sparse(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceSumSparse") ⇒ Object 



4051
4052
4053
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4051

def self.sparse_reduce_sum_sparse(input_indices, input_values, input_shape, reduction_axes, keep_dims: false, typeT: nil, name: "SparseReduceSumSparse")
  self.execute("SparseReduceSumSparse", [input_indices, input_values, input_shape, reduction_axes], keep_dims: keep_dims, T: typeT, name: name)
end

.sparse_reorder(input_indices, input_values, input_shape, typeT: nil, name: "SparseReorder") ⇒ Object 



4055
4056
4057
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4055

def self.sparse_reorder(input_indices, input_values, input_shape, typeT: nil, name: "SparseReorder")
  self.execute("SparseReorder", [input_indices, input_values, input_shape], T: typeT, name: name)
end

.sparse_reshape(input_indices, input_shape, new_shape, name: "SparseReshape") ⇒ Object 



4059
4060
4061
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4059

def self.sparse_reshape(input_indices, input_shape, new_shape, name: "SparseReshape")
  self.execute("SparseReshape", [input_indices, input_shape, new_shape], name: name)
end

.sparse_segment_mean(data, indices, segment_ids, typeT: nil, tidx: :int32, name: "SparseSegmentMean") ⇒ Object 



4063
4064
4065
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4063

def self.sparse_segment_mean(data, indices, segment_ids, typeT: nil, tidx: :int32, name: "SparseSegmentMean")
  self.execute("SparseSegmentMean", [data, indices, segment_ids], T: typeT, Tidx: tidx, name: name)
end

.sparse_segment_mean_grad(grad, indices, segment_ids, output_dim0, typeT: nil, tidx: :int32, name: "SparseSegmentMeanGrad") ⇒ Object 



4067
4068
4069
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4067

def self.sparse_segment_mean_grad(grad, indices, segment_ids, output_dim0, typeT: nil, tidx: :int32, name: "SparseSegmentMeanGrad")
  self.execute("SparseSegmentMeanGrad", [grad, indices, segment_ids, output_dim0], T: typeT, Tidx: tidx, name: name)
end

.sparse_segment_mean_with_num_segments(data, indices, segment_ids, num_segments, typeT: nil, tidx: :int32, tnumsegments: :int32, name: "SparseSegmentMeanWithNumSegments") ⇒ Object 



4071
4072
4073
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4071

def self.sparse_segment_mean_with_num_segments(data, indices, segment_ids, num_segments, typeT: nil, tidx: :int32, tnumsegments: :int32, name: "SparseSegmentMeanWithNumSegments")
  self.execute("SparseSegmentMeanWithNumSegments", [data, indices, segment_ids, num_segments], T: typeT, Tidx: tidx, Tnumsegments: tnumsegments, name: name)
end

.sparse_segment_sqrt_n(data, indices, segment_ids, typeT: nil, tidx: :int32, name: "SparseSegmentSqrtN") ⇒ Object 



4075
4076
4077
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4075

def self.sparse_segment_sqrt_n(data, indices, segment_ids, typeT: nil, tidx: :int32, name: "SparseSegmentSqrtN")
  self.execute("SparseSegmentSqrtN", [data, indices, segment_ids], T: typeT, Tidx: tidx, name: name)
end

.sparse_segment_sqrt_n_grad(grad, indices, segment_ids, output_dim0, typeT: nil, tidx: :int32, name: "SparseSegmentSqrtNGrad") ⇒ Object 



4079
4080
4081
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4079

def self.sparse_segment_sqrt_n_grad(grad, indices, segment_ids, output_dim0, typeT: nil, tidx: :int32, name: "SparseSegmentSqrtNGrad")
  self.execute("SparseSegmentSqrtNGrad", [grad, indices, segment_ids, output_dim0], T: typeT, Tidx: tidx, name: name)
end

.sparse_segment_sqrt_n_with_num_segments(data, indices, segment_ids, num_segments, typeT: nil, tidx: :int32, tnumsegments: :int32, name: "SparseSegmentSqrtNWithNumSegments") ⇒ Object 



4083
4084
4085
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4083

def self.sparse_segment_sqrt_n_with_num_segments(data, indices, segment_ids, num_segments, typeT: nil, tidx: :int32, tnumsegments: :int32, name: "SparseSegmentSqrtNWithNumSegments")
  self.execute("SparseSegmentSqrtNWithNumSegments", [data, indices, segment_ids, num_segments], T: typeT, Tidx: tidx, Tnumsegments: tnumsegments, name: name)
end

.sparse_segment_sum(data, indices, segment_ids, typeT: nil, tidx: :int32, name: "SparseSegmentSum") ⇒ Object 



4087
4088
4089
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4087

def self.sparse_segment_sum(data, indices, segment_ids, typeT: nil, tidx: :int32, name: "SparseSegmentSum")
  self.execute("SparseSegmentSum", [data, indices, segment_ids], T: typeT, Tidx: tidx, name: name)
end

.sparse_segment_sum_with_num_segments(data, indices, segment_ids, num_segments, typeT: nil, tidx: :int32, tnumsegments: :int32, name: "SparseSegmentSumWithNumSegments") ⇒ Object 



4091
4092
4093
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4091

def self.sparse_segment_sum_with_num_segments(data, indices, segment_ids, num_segments, typeT: nil, tidx: :int32, tnumsegments: :int32, name: "SparseSegmentSumWithNumSegments")
  self.execute("SparseSegmentSumWithNumSegments", [data, indices, segment_ids, num_segments], T: typeT, Tidx: tidx, Tnumsegments: tnumsegments, name: name)
end

.sparse_slice(indices, values, shape, start, size, typeT: nil, name: "SparseSlice") ⇒ Object 



4095
4096
4097
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4095

def self.sparse_slice(indices, values, shape, start, size, typeT: nil, name: "SparseSlice")
  self.execute("SparseSlice", [indices, values, shape, start, size], T: typeT, name: name)
end

.sparse_slice_grad(backprop_val_grad, input_indices, input_start, output_indices, typeT: nil, name: "SparseSliceGrad") ⇒ Object 



4099
4100
4101
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4099

def self.sparse_slice_grad(backprop_val_grad, input_indices, input_start, output_indices, typeT: nil, name: "SparseSliceGrad")
  self.execute("SparseSliceGrad", [backprop_val_grad, input_indices, input_start, output_indices], T: typeT, name: name)
end

.sparse_softmax(sp_indices, sp_values, sp_shape, typeT: nil, name: "SparseSoftmax") ⇒ Object 



4103
4104
4105
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4103

def self.sparse_softmax(sp_indices, sp_values, sp_shape, typeT: nil, name: "SparseSoftmax")
  self.execute("SparseSoftmax", [sp_indices, sp_values, sp_shape], T: typeT, name: name)
end

.sparse_softmax_cross_entropy_with_logits(features, labels, typeT: nil, tlabels: :int64, name: "SparseSoftmaxCrossEntropyWithLogits") ⇒ Object 



4107
4108
4109
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4107

def self.sparse_softmax_cross_entropy_with_logits(features, labels, typeT: nil, tlabels: :int64, name: "SparseSoftmaxCrossEntropyWithLogits")
  self.execute("SparseSoftmaxCrossEntropyWithLogits", [features, labels], T: typeT, Tlabels: tlabels, name: name)
end

.sparse_sparse_maximum(a_indices, a_values, a_shape, b_indices, b_values, b_shape, typeT: nil, name: "SparseSparseMaximum") ⇒ Object 



4111
4112
4113
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4111

def self.sparse_sparse_maximum(a_indices, a_values, a_shape, b_indices, b_values, b_shape, typeT: nil, name: "SparseSparseMaximum")
  self.execute("SparseSparseMaximum", [a_indices, a_values, a_shape, b_indices, b_values, b_shape], T: typeT, name: name)
end

.sparse_sparse_minimum(a_indices, a_values, a_shape, b_indices, b_values, b_shape, typeT: nil, name: "SparseSparseMinimum") ⇒ Object 



4115
4116
4117
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4115

def self.sparse_sparse_minimum(a_indices, a_values, a_shape, b_indices, b_values, b_shape, typeT: nil, name: "SparseSparseMinimum")
  self.execute("SparseSparseMinimum", [a_indices, a_values, a_shape, b_indices, b_values, b_shape], T: typeT, name: name)
end

.sparse_split(split_dim, indices, values, shape, num_split: nil, typeT: nil, name: "SparseSplit") ⇒ Object 



4119
4120
4121
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4119

def self.sparse_split(split_dim, indices, values, shape, num_split: nil, typeT: nil, name: "SparseSplit")
  self.execute("SparseSplit", [split_dim, indices, values, shape], num_split: num_split, T: typeT, name: name)
end

.sparse_tensor_dense_add(a_indices, a_values, a_shape, b, typeT: nil, tindices: nil, name: "SparseTensorDenseAdd") ⇒ Object 



4123
4124
4125
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4123

def self.sparse_tensor_dense_add(a_indices, a_values, a_shape, b, typeT: nil, tindices: nil, name: "SparseTensorDenseAdd")
  self.execute("SparseTensorDenseAdd", [a_indices, a_values, a_shape, b], T: typeT, Tindices: tindices, name: name)
end

.sparse_tensor_dense_mat_mul(a_indices, a_values, a_shape, b, typeT: nil, tindices: :int64, adjoint_a: false, adjoint_b: false, name: "SparseTensorDenseMatMul") ⇒ Object 



4127
4128
4129
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4127

def self.sparse_tensor_dense_mat_mul(a_indices, a_values, a_shape, b, typeT: nil, tindices: :int64, adjoint_a: false, adjoint_b: false, name: "SparseTensorDenseMatMul")
  self.execute("SparseTensorDenseMatMul", [a_indices, a_values, a_shape, b], T: typeT, Tindices: tindices, adjoint_a: adjoint_a, adjoint_b: adjoint_b, name: name)
end

.sparse_tensor_slice_dataset(indices, values, dense_shape, tvalues: nil, name: "SparseTensorSliceDataset") ⇒ Object 



4131
4132
4133
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4131

def self.sparse_tensor_slice_dataset(indices, values, dense_shape, tvalues: nil, name: "SparseTensorSliceDataset")
  self.execute("SparseTensorSliceDataset", [indices, values, dense_shape], Tvalues: tvalues, name: name)
end

.sparse_tensor_to_csr_sparse_matrix(indices, values, dense_shape, typeT: nil, name: "SparseTensorToCSRSparseMatrix") ⇒ Object 



4135
4136
4137
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4135

def self.sparse_tensor_to_csr_sparse_matrix(indices, values, dense_shape, typeT: nil, name: "SparseTensorToCSRSparseMatrix")
  self.execute("SparseTensorToCSRSparseMatrix", [indices, values, dense_shape], T: typeT, name: name)
end

.sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value, validate_indices: true, typeT: nil, tindices: nil, name: "SparseToDense") ⇒ Object 



4139
4140
4141
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4139

def self.sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value, validate_indices: true, typeT: nil, tindices: nil, name: "SparseToDense")
  self.execute("SparseToDense", [sparse_indices, output_shape, sparse_values, default_value], validate_indices: validate_indices, T: typeT, Tindices: tindices, name: name)
end

.sparse_to_sparse_set_operation(set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, set_operation: "", validate_indices: true, typeT: nil, name: "SparseToSparseSetOperation") ⇒ Object 



4143
4144
4145
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4143

def self.sparse_to_sparse_set_operation(set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, set_operation: "", validate_indices: true, typeT: nil, name: "SparseToSparseSetOperation")
  self.execute("SparseToSparseSetOperation", [set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape], set_operation: set_operation, validate_indices: validate_indices, T: typeT, name: name)
end

.split(split_dim, value, num_split: nil, typeT: nil, name: "Split") ⇒ Object 



4147
4148
4149
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4147

def self.split(split_dim, value, num_split: nil, typeT: nil, name: "Split")
  self.execute("Split", [split_dim, value], num_split: num_split, T: typeT, name: name)
end

.split_v(value, size_splits, split_dim, num_split: nil, typeT: nil, tlen: :int64, name: "SplitV") ⇒ Object 



4151
4152
4153
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4151

def self.split_v(value, size_splits, split_dim, num_split: nil, typeT: nil, tlen: :int64, name: "SplitV")
  self.execute("SplitV", [value, size_splits, split_dim], num_split: num_split, T: typeT, Tlen: tlen, name: name)
end

.sql_dataset(driver_name, data_source_name, query, output_types: nil, output_shapes: nil, name: "SqlDataset") ⇒ Object 



4155
4156
4157
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4155

def self.sql_dataset(driver_name, data_source_name, query, output_types: nil, output_shapes: nil, name: "SqlDataset")
  self.execute("SqlDataset", [driver_name, data_source_name, query], output_types: output_types, output_shapes: output_shapes, name: name)
end

.sqrt(x, typeT: nil, name: "Sqrt") ⇒ Object 



4159
4160
4161
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4159

def self.sqrt(x, typeT: nil, name: "Sqrt")
  self.execute("Sqrt", [x], T: typeT, name: name)
end

.sqrt_grad(y, dy, typeT: nil, name: "SqrtGrad") ⇒ Object 



4163
4164
4165
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4163

def self.sqrt_grad(y, dy, typeT: nil, name: "SqrtGrad")
  self.execute("SqrtGrad", [y, dy], T: typeT, name: name)
end

.square(x, typeT: nil, name: "Square") ⇒ Object 



4167
4168
4169
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4167

def self.square(x, typeT: nil, name: "Square")
  self.execute("Square", [x], T: typeT, name: name)
end

.squared_difference(x, y, typeT: nil, name: "SquaredDifference") ⇒ Object 



4171
4172
4173
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4171

def self.squared_difference(x, y, typeT: nil, name: "SquaredDifference")
  self.execute("SquaredDifference", [x, y], T: typeT, name: name)
end

.squeeze(input, typeT: nil, squeeze_dims: [], name: "Squeeze") ⇒ Object 



4175
4176
4177
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4175

def self.squeeze(input, typeT: nil, squeeze_dims: [], name: "Squeeze")
  self.execute("Squeeze", [input], T: typeT, squeeze_dims: squeeze_dims, name: name)
end

.stack(elem_type: nil, stack_name: "", name: "Stack") ⇒ Object 



4179
4180
4181
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4179

def self.stack(elem_type: nil, stack_name: "", name: "Stack")
  self.execute("Stack", [], elem_type: elem_type, stack_name: stack_name, name: name)
end

.stack_close(handle, name: "StackClose") ⇒ Object 



4183
4184
4185
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4183

def self.stack_close(handle, name: "StackClose")
  self.execute("StackClose", [handle], name: name)
end

.stack_close_v2(handle, name: "StackCloseV2") ⇒ Object 



4187
4188
4189
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4187

def self.stack_close_v2(handle, name: "StackCloseV2")
  self.execute("StackCloseV2", [handle], name: name)
end

.stack_pop(handle, elem_type: nil, name: "StackPop") ⇒ Object 



4191
4192
4193
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4191

def self.stack_pop(handle, elem_type: nil, name: "StackPop")
  self.execute("StackPop", [handle], elem_type: elem_type, name: name)
end

.stack_pop_v2(handle, elem_type: nil, name: "StackPopV2") ⇒ Object 



4195
4196
4197
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4195

def self.stack_pop_v2(handle, elem_type: nil, name: "StackPopV2")
  self.execute("StackPopV2", [handle], elem_type: elem_type, name: name)
end

.stack_push(handle, elem, typeT: nil, swap_memory: false, name: "StackPush") ⇒ Object 



4199
4200
4201
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4199

def self.stack_push(handle, elem, typeT: nil, swap_memory: false, name: "StackPush")
  self.execute("StackPush", [handle, elem], T: typeT, swap_memory: swap_memory, name: name)
end

.stack_push_v2(handle, elem, typeT: nil, swap_memory: false, name: "StackPushV2") ⇒ Object 



4203
4204
4205
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4203

def self.stack_push_v2(handle, elem, typeT: nil, swap_memory: false, name: "StackPushV2")
  self.execute("StackPushV2", [handle, elem], T: typeT, swap_memory: swap_memory, name: name)
end

.stack_v2(max_size, elem_type: nil, stack_name: "", name: "StackV2") ⇒ Object 



4207
4208
4209
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4207

def self.stack_v2(max_size, elem_type: nil, stack_name: "", name: "StackV2")
  self.execute("StackV2", [max_size], elem_type: elem_type, stack_name: stack_name, name: name)
end

.stage(values, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "Stage") ⇒ Object 



4211
4212
4213
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4211

def self.stage(values, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "Stage")
  self.execute("Stage", [values], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.stage_clear(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "StageClear") ⇒ Object 



4215
4216
4217
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4215

def self.stage_clear(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "StageClear")
  self.execute("StageClear", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.stage_peek(index, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "StagePeek") ⇒ Object 



4219
4220
4221
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4219

def self.stage_peek(index, capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "StagePeek")
  self.execute("StagePeek", [index], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.stage_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "StageSize") ⇒ Object 



4223
4224
4225
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4223

def self.stage_size(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "StageSize")
  self.execute("StageSize", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.stateful_partitioned_call(args, tin: nil, tout: nil, f: nil, config: "", config_proto: "", executor_type: "", name: "StatefulPartitionedCall") ⇒ Object 



4227
4228
4229
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4227

def self.stateful_partitioned_call(args, tin: nil, tout: nil, f: nil, config: "", config_proto: "", executor_type: "", name: "StatefulPartitionedCall")
  self.execute("StatefulPartitionedCall", [args], Tin: tin, Tout: tout, f: f, config: config, config_proto: config_proto, executor_type: executor_type, name: name)
end

.stateful_random_binomial(resource, algorithm, shape, counts, probs, s: nil, typeT: :double, dtype: :int64, name: "StatefulRandomBinomial") ⇒ Object 



4231
4232
4233
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4231

def self.stateful_random_binomial(resource, algorithm, shape, counts, probs, s: nil, typeT: :double, dtype: :int64, name: "StatefulRandomBinomial")
  self.execute("StatefulRandomBinomial", [resource, algorithm, shape, counts, probs], S: s, T: typeT, dtype: dtype, name: name)
end

.stateful_standard_normal(resource, shape, dtype: :float, shape_dtype: :int64, name: "StatefulStandardNormal") ⇒ Object 



4235
4236
4237
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4235

def self.stateful_standard_normal(resource, shape, dtype: :float, shape_dtype: :int64, name: "StatefulStandardNormal")
  self.execute("StatefulStandardNormal", [resource, shape], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.stateful_standard_normal_v2(resource, algorithm, shape, dtype: :float, shape_dtype: :int64, name: "StatefulStandardNormalV2") ⇒ Object 



4239
4240
4241
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4239

def self.stateful_standard_normal_v2(resource, algorithm, shape, dtype: :float, shape_dtype: :int64, name: "StatefulStandardNormalV2")
  self.execute("StatefulStandardNormalV2", [resource, algorithm, shape], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.stateful_truncated_normal(resource, algorithm, shape, dtype: :float, shape_dtype: :int64, name: "StatefulTruncatedNormal") ⇒ Object 



4243
4244
4245
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4243

def self.stateful_truncated_normal(resource, algorithm, shape, dtype: :float, shape_dtype: :int64, name: "StatefulTruncatedNormal")
  self.execute("StatefulTruncatedNormal", [resource, algorithm, shape], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.stateful_uniform(resource, algorithm, shape, dtype: :float, shape_dtype: :int64, name: "StatefulUniform") ⇒ Object 



4247
4248
4249
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4247

def self.stateful_uniform(resource, algorithm, shape, dtype: :float, shape_dtype: :int64, name: "StatefulUniform")
  self.execute("StatefulUniform", [resource, algorithm, shape], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.stateful_uniform_full_int(resource, algorithm, shape, dtype: :uint64, shape_dtype: :int64, name: "StatefulUniformFullInt") ⇒ Object 



4251
4252
4253
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4251

def self.stateful_uniform_full_int(resource, algorithm, shape, dtype: :uint64, shape_dtype: :int64, name: "StatefulUniformFullInt")
  self.execute("StatefulUniformFullInt", [resource, algorithm, shape], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.stateful_uniform_int(resource, algorithm, shape, minval, maxval, dtype: :int64, shape_dtype: :int64, name: "StatefulUniformInt") ⇒ Object 



4255
4256
4257
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4255

def self.stateful_uniform_int(resource, algorithm, shape, minval, maxval, dtype: :int64, shape_dtype: :int64, name: "StatefulUniformInt")
  self.execute("StatefulUniformInt", [resource, algorithm, shape, minval, maxval], dtype: dtype, shape_dtype: shape_dtype, name: name)
end

.stateless_if(cond, input, tcond: nil, tin: nil, tout: nil, then_branch: nil, else_branch: nil, output_shapes: [], name: "StatelessIf") ⇒ Object 



4259
4260
4261
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4259

def self.stateless_if(cond, input, tcond: nil, tin: nil, tout: nil, then_branch: nil, else_branch: nil, output_shapes: [], name: "StatelessIf")
  self.execute("StatelessIf", [cond, input], Tcond: tcond, Tin: tin, Tout: tout, then_branch: then_branch, else_branch: else_branch, output_shapes: output_shapes, name: name)
end

.stateless_multinomial(logits, num_samples, seed, typeT: nil, tseed: :int64, output_dtype: :int64, name: "StatelessMultinomial") ⇒ Object 



4263
4264
4265
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4263

def self.stateless_multinomial(logits, num_samples, seed, typeT: nil, tseed: :int64, output_dtype: :int64, name: "StatelessMultinomial")
  self.execute("StatelessMultinomial", [logits, num_samples, seed], T: typeT, Tseed: tseed, output_dtype: output_dtype, name: name)
end

.stateless_random_normal(shape, seed, dtype: :float, typeT: :int32, tseed: :int64, name: "StatelessRandomNormal") ⇒ Object 



4267
4268
4269
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4267

def self.stateless_random_normal(shape, seed, dtype: :float, typeT: :int32, tseed: :int64, name: "StatelessRandomNormal")
  self.execute("StatelessRandomNormal", [shape, seed], dtype: dtype, T: typeT, Tseed: tseed, name: name)
end

.stateless_random_uniform(shape, seed, dtype: :float, typeT: :int32, tseed: :int64, name: "StatelessRandomUniform") ⇒ Object 



4271
4272
4273
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4271

def self.stateless_random_uniform(shape, seed, dtype: :float, typeT: :int32, tseed: :int64, name: "StatelessRandomUniform")
  self.execute("StatelessRandomUniform", [shape, seed], dtype: dtype, T: typeT, Tseed: tseed, name: name)
end

.stateless_random_uniform_int(shape, seed, minval, maxval, dtype: nil, typeT: nil, tseed: :int64, name: "StatelessRandomUniformInt") ⇒ Object 



4275
4276
4277
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4275

def self.stateless_random_uniform_int(shape, seed, minval, maxval, dtype: nil, typeT: nil, tseed: :int64, name: "StatelessRandomUniformInt")
  self.execute("StatelessRandomUniformInt", [shape, seed, minval, maxval], dtype: dtype, T: typeT, Tseed: tseed, name: name)
end

.stateless_truncated_normal(shape, seed, dtype: :float, typeT: :int32, tseed: :int64, name: "StatelessTruncatedNormal") ⇒ Object 



4279
4280
4281
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4279

def self.stateless_truncated_normal(shape, seed, dtype: :float, typeT: :int32, tseed: :int64, name: "StatelessTruncatedNormal")
  self.execute("StatelessTruncatedNormal", [shape, seed], dtype: dtype, T: typeT, Tseed: tseed, name: name)
end

.stateless_while(input, typeT: nil, cond: nil, body: nil, output_shapes: [], parallel_iterations: 10, name: "StatelessWhile") ⇒ Object 



4283
4284
4285
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4283

def self.stateless_while(input, typeT: nil, cond: nil, body: nil, output_shapes: [], parallel_iterations: 10, name: "StatelessWhile")
  self.execute("StatelessWhile", [input], T: typeT, cond: cond, body: body, output_shapes: output_shapes, parallel_iterations: parallel_iterations, name: name)
end

.static_regex_full_match(input, pattern: "", name: "StaticRegexFullMatch") ⇒ Object 



4287
4288
4289
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4287

def self.static_regex_full_match(input, pattern: "", name: "StaticRegexFullMatch")
  self.execute("StaticRegexFullMatch", [input], pattern: pattern, name: name)
end

.static_regex_replace(input, pattern: "", rewrite: "", replace_global: true, name: "StaticRegexReplace") ⇒ Object 



4291
4292
4293
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4291

def self.static_regex_replace(input, pattern: "", rewrite: "", replace_global: true, name: "StaticRegexReplace")
  self.execute("StaticRegexReplace", [input], pattern: pattern, rewrite: rewrite, replace_global: replace_global, name: name)
end

.stats_aggregator_handle(container: "", shared_name: "", name: "StatsAggregatorHandle") ⇒ Object 



4295
4296
4297
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4295

def self.stats_aggregator_handle(container: "", shared_name: "", name: "StatsAggregatorHandle")
  self.execute("StatsAggregatorHandle", [], container: container, shared_name: shared_name, name: name)
end

.stats_aggregator_handle_v2(container: "", shared_name: "", name: "StatsAggregatorHandleV2") ⇒ Object 



4299
4300
4301
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4299

def self.stats_aggregator_handle_v2(container: "", shared_name: "", name: "StatsAggregatorHandleV2")
  self.execute("StatsAggregatorHandleV2", [], container: container, shared_name: shared_name, name: name)
end

.stats_aggregator_set_summary_writer(stats_aggregator, summary, name: "StatsAggregatorSetSummaryWriter") ⇒ Object 



4303
4304
4305
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4303

def self.stats_aggregator_set_summary_writer(stats_aggregator, summary, name: "StatsAggregatorSetSummaryWriter")
  self.execute("StatsAggregatorSetSummaryWriter", [stats_aggregator, summary], name: name)
end

.stats_aggregator_summary(iterator, name: "StatsAggregatorSummary") ⇒ Object 



4307
4308
4309
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4307

def self.stats_aggregator_summary(iterator, name: "StatsAggregatorSummary")
  self.execute("StatsAggregatorSummary", [iterator], name: name)
end

.stop_gradient(input, typeT: nil, name: "StopGradient") ⇒ Object 



4311
4312
4313
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4311

def self.stop_gradient(input, typeT: nil, name: "StopGradient")
  self.execute("StopGradient", [input], T: typeT, name: name)
end

.strided_slice(input, start, stop, strides, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "StridedSlice") ⇒ Object 



4315
4316
4317
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4315

def self.strided_slice(input, start, stop, strides, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "StridedSlice")
  self.execute("StridedSlice", [input, start, stop, strides], T: typeT, Index: index, begin_mask: begin_mask, end_mask: end_mask, ellipsis_mask: ellipsis_mask, new_axis_mask: new_axis_mask, shrink_axis_mask: shrink_axis_mask, name: name)
end

.strided_slice_assign(ref, start, stop, strides, value, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "StridedSliceAssign") ⇒ Object 



4319
4320
4321
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4319

def self.strided_slice_assign(ref, start, stop, strides, value, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "StridedSliceAssign")
  self.execute("StridedSliceAssign", [ref, start, stop, strides, value], T: typeT, Index: index, begin_mask: begin_mask, end_mask: end_mask, ellipsis_mask: ellipsis_mask, new_axis_mask: new_axis_mask, shrink_axis_mask: shrink_axis_mask, name: name)
end

.strided_slice_grad(shape, start, stop, strides, dy, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "StridedSliceGrad") ⇒ Object 



4323
4324
4325
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4323

def self.strided_slice_grad(shape, start, stop, strides, dy, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "StridedSliceGrad")
  self.execute("StridedSliceGrad", [shape, start, stop, strides, dy], T: typeT, Index: index, begin_mask: begin_mask, end_mask: end_mask, ellipsis_mask: ellipsis_mask, new_axis_mask: new_axis_mask, shrink_axis_mask: shrink_axis_mask, name: name)
end

.string_format(inputs, typeT: nil, template: "%s", placeholder: "%s", summarize: 3, name: "StringFormat") ⇒ Object 



4327
4328
4329
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4327

def self.string_format(inputs, typeT: nil, template: "%s", placeholder: "%s", summarize: 3, name: "StringFormat")
  self.execute("StringFormat", [inputs], T: typeT, template: template, placeholder: placeholder, summarize: summarize, name: name)
end

.string_join(inputs, n: nil, separator: "", name: "StringJoin") ⇒ Object 



4331
4332
4333
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4331

def self.string_join(inputs, n: nil, separator: "", name: "StringJoin")
  self.execute("StringJoin", [inputs], N: n, separator: separator, name: name)
end

.string_length(input, unit: "BYTE", name: "StringLength") ⇒ Object 



4335
4336
4337
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4335

def self.string_length(input, unit: "BYTE", name: "StringLength")
  self.execute("StringLength", [input], unit: unit, name: name)
end

.string_lower(input, encoding: "", name: "StringLower") ⇒ Object 



4339
4340
4341
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4339

def self.string_lower(input, encoding: "", name: "StringLower")
  self.execute("StringLower", [input], encoding: encoding, name: name)
end

.string_n_grams(data, data_splits, separator: "", ngram_widths: nil, left_pad: "", right_pad: "", pad_width: nil, preserve_short_sequences: nil, tsplits: :int64, name: "StringNGrams") ⇒ Object 



4343
4344
4345
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4343

def self.string_n_grams(data, data_splits, separator: "", ngram_widths: nil, left_pad: "", right_pad: "", pad_width: nil, preserve_short_sequences: nil, tsplits: :int64, name: "StringNGrams")
  self.execute("StringNGrams", [data, data_splits], separator: separator, ngram_widths: ngram_widths, left_pad: left_pad, right_pad: right_pad, pad_width: pad_width, preserve_short_sequences: preserve_short_sequences, Tsplits: tsplits, name: name)
end

.string_split(input, delimiter, skip_empty: true, name: "StringSplit") ⇒ Object 



4347
4348
4349
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4347

def self.string_split(input, delimiter, skip_empty: true, name: "StringSplit")
  self.execute("StringSplit", [input, delimiter], skip_empty: skip_empty, name: name)
end

.string_split_v2(input, sep, maxsplit: -1,, name: "StringSplitV2") ⇒ Object 



4351
4352
4353
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4351

def self.string_split_v2(input, sep, maxsplit: -1, name: "StringSplitV2")
  self.execute("StringSplitV2", [input, sep], maxsplit: maxsplit, name: name)
end

.string_strip(input, name: "StringStrip") ⇒ Object 



4355
4356
4357
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4355

def self.string_strip(input, name: "StringStrip")
  self.execute("StringStrip", [input], name: name)
end

.string_to_hash_bucket(string_tensor, num_buckets: nil, name: "StringToHashBucket") ⇒ Object 



4359
4360
4361
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4359

def self.string_to_hash_bucket(string_tensor, num_buckets: nil, name: "StringToHashBucket")
  self.execute("StringToHashBucket", [string_tensor], num_buckets: num_buckets, name: name)
end

.string_to_hash_bucket_fast(input, num_buckets: nil, name: "StringToHashBucketFast") ⇒ Object 



4363
4364
4365
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4363

def self.string_to_hash_bucket_fast(input, num_buckets: nil, name: "StringToHashBucketFast")
  self.execute("StringToHashBucketFast", [input], num_buckets: num_buckets, name: name)
end

.string_to_hash_bucket_strong(input, num_buckets: nil, key: nil, name: "StringToHashBucketStrong") ⇒ Object 



4367
4368
4369
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4367

def self.string_to_hash_bucket_strong(input, num_buckets: nil, key: nil, name: "StringToHashBucketStrong")
  self.execute("StringToHashBucketStrong", [input], num_buckets: num_buckets, key: key, name: name)
end

.string_to_number(string_tensor, out_type: :float, name: "StringToNumber") ⇒ Object 



4371
4372
4373
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4371

def self.string_to_number(string_tensor, out_type: :float, name: "StringToNumber")
  self.execute("StringToNumber", [string_tensor], out_type: out_type, name: name)
end

.string_upper(input, encoding: "", name: "StringUpper") ⇒ Object 



4375
4376
4377
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4375

def self.string_upper(input, encoding: "", name: "StringUpper")
  self.execute("StringUpper", [input], encoding: encoding, name: name)
end

.sub(x, y, typeT: nil, name: "Sub") ⇒ Object 



4379
4380
4381
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4379

def self.sub(x, y, typeT: nil, name: "Sub")
  self.execute("Sub", [x, y], T: typeT, name: name)
end

.substr(input, pos, len, typeT: nil, unit: "BYTE", name: "Substr") ⇒ Object 



4383
4384
4385
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4383

def self.substr(input, pos, len, typeT: nil, unit: "BYTE", name: "Substr")
  self.execute("Substr", [input, pos, len], T: typeT, unit: unit, name: name)
end

.sum(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Sum") ⇒ Object 



4387
4388
4389
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4387

def self.sum(input, reduction_indices, keep_dims: false, typeT: nil, tidx: :int32, name: "Sum")
  self.execute("Sum", [input, reduction_indices], keep_dims: keep_dims, T: typeT, Tidx: tidx, name: name)
end

.summary_writer(shared_name: "", container: "", name: "SummaryWriter") ⇒ Object 



4391
4392
4393
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4391

def self.summary_writer(shared_name: "", container: "", name: "SummaryWriter")
  self.execute("SummaryWriter", [], shared_name: shared_name, container: container, name: name)
end

.svd(input, compute_uv: true, full_matrices: false, typeT: nil, name: "Svd") ⇒ Object 



4395
4396
4397
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4395

def self.svd(input, compute_uv: true, full_matrices: false, typeT: nil, name: "Svd")
  self.execute("Svd", [input], compute_uv: compute_uv, full_matrices: full_matrices, T: typeT, name: name)
end

.switch(data, pred, typeT: nil, name: "Switch") ⇒ Object 



4399
4400
4401
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4399

def self.switch(data, pred, typeT: nil, name: "Switch")
  self.execute("Switch", [data, pred], T: typeT, name: name)
end

.symbolic_gradient(input, tin: nil, tout: nil, f: nil, name: "SymbolicGradient") ⇒ Object 



4403
4404
4405
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4403

def self.symbolic_gradient(input, tin: nil, tout: nil, f: nil, name: "SymbolicGradient")
  self.execute("SymbolicGradient", [input], Tin: tin, Tout: tout, f: f, name: name)
end

.take_dataset(input_dataset, count, output_types: nil, output_shapes: nil, name: "TakeDataset") ⇒ Object 



4447
4448
4449
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4447

def self.take_dataset(input_dataset, count, output_types: nil, output_shapes: nil, name: "TakeDataset")
  self.execute("TakeDataset", [input_dataset, count], output_types: output_types, output_shapes: output_shapes, name: name)
end

.take_many_sparse_from_tensors_map(sparse_handles, dtype: nil, container: "", shared_name: "", name: "TakeManySparseFromTensorsMap") ⇒ Object 



4451
4452
4453
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4451

def self.take_many_sparse_from_tensors_map(sparse_handles, dtype: nil, container: "", shared_name: "", name: "TakeManySparseFromTensorsMap")
  self.execute("TakeManySparseFromTensorsMap", [sparse_handles], dtype: dtype, container: container, shared_name: shared_name, name: name)
end

.take_while_dataset(input_dataset, other_arguments, predicate: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "TakeWhileDataset") ⇒ Object 



4455
4456
4457
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4455

def self.take_while_dataset(input_dataset, other_arguments, predicate: nil, targuments: nil, output_types: nil, output_shapes: nil, name: "TakeWhileDataset")
  self.execute("TakeWhileDataset", [input_dataset, other_arguments], predicate: predicate, Targuments: targuments, output_types: output_types, output_shapes: output_shapes, name: name)
end

.tan(x, typeT: nil, name: "Tan") ⇒ Object 



4459
4460
4461
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4459

def self.tan(x, typeT: nil, name: "Tan")
  self.execute("Tan", [x], T: typeT, name: name)
end

.tanh(x, typeT: nil, name: "Tanh") ⇒ Object 



4463
4464
4465
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4463

def self.tanh(x, typeT: nil, name: "Tanh")
  self.execute("Tanh", [x], T: typeT, name: name)
end

.tanh_grad(y, dy, typeT: nil, name: "TanhGrad") ⇒ Object 



4467
4468
4469
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4467

def self.tanh_grad(y, dy, typeT: nil, name: "TanhGrad")
  self.execute("TanhGrad", [y, dy], T: typeT, name: name)
end

.temporary_variable(shape: nil, dtype: nil, var_name: "", name: "TemporaryVariable") ⇒ Object 



4471
4472
4473
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4471

def self.temporary_variable(shape: nil, dtype: nil, var_name: "", name: "TemporaryVariable")
  self.execute("TemporaryVariable", [], shape: shape, dtype: dtype, var_name: var_name, name: name)
end

.tensor_array(size, dtype: nil, dynamic_size: false, clear_after_read: true, tensor_array_name: "", element_shape: [], name: "TensorArray") ⇒ Object 



4475
4476
4477
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4475

def self.tensor_array(size, dtype: nil, dynamic_size: false, clear_after_read: true, tensor_array_name: "", element_shape: [], name: "TensorArray")
  self.execute("TensorArray", [size], dtype: dtype, dynamic_size: dynamic_size, clear_after_read: clear_after_read, tensor_array_name: tensor_array_name, element_shape: element_shape, name: name)
end

.tensor_array_close(handle, name: "TensorArrayClose") ⇒ Object 



4479
4480
4481
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4479

def self.tensor_array_close(handle, name: "TensorArrayClose")
  self.execute("TensorArrayClose", [handle], name: name)
end

.tensor_array_close_v2(handle, name: "TensorArrayCloseV2") ⇒ Object 



4483
4484
4485
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4483

def self.tensor_array_close_v2(handle, name: "TensorArrayCloseV2")
  self.execute("TensorArrayCloseV2", [handle], name: name)
end

.tensor_array_close_v3(handle, name: "TensorArrayCloseV3") ⇒ Object 



4487
4488
4489
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4487

def self.tensor_array_close_v3(handle, name: "TensorArrayCloseV3")
  self.execute("TensorArrayCloseV3", [handle], name: name)
end

.tensor_array_concat(handle, flow_in, dtype: nil, element_shape_except0: [], name: "TensorArrayConcat") ⇒ Object 



4491
4492
4493
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4491

def self.tensor_array_concat(handle, flow_in, dtype: nil, element_shape_except0: [], name: "TensorArrayConcat")
  self.execute("TensorArrayConcat", [handle, flow_in], dtype: dtype, element_shape_except0: element_shape_except0, name: name)
end

.tensor_array_concat_v2(handle, flow_in, dtype: nil, element_shape_except0: [], name: "TensorArrayConcatV2") ⇒ Object 



4495
4496
4497
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4495

def self.tensor_array_concat_v2(handle, flow_in, dtype: nil, element_shape_except0: [], name: "TensorArrayConcatV2")
  self.execute("TensorArrayConcatV2", [handle, flow_in], dtype: dtype, element_shape_except0: element_shape_except0, name: name)
end

.tensor_array_concat_v3(handle, flow_in, dtype: nil, element_shape_except0: [], name: "TensorArrayConcatV3") ⇒ Object 



4499
4500
4501
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4499

def self.tensor_array_concat_v3(handle, flow_in, dtype: nil, element_shape_except0: [], name: "TensorArrayConcatV3")
  self.execute("TensorArrayConcatV3", [handle, flow_in], dtype: dtype, element_shape_except0: element_shape_except0, name: name)
end

.tensor_array_gather(handle, indices, flow_in, dtype: nil, element_shape: [], name: "TensorArrayGather") ⇒ Object 



4503
4504
4505
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4503

def self.tensor_array_gather(handle, indices, flow_in, dtype: nil, element_shape: [], name: "TensorArrayGather")
  self.execute("TensorArrayGather", [handle, indices, flow_in], dtype: dtype, element_shape: element_shape, name: name)
end

.tensor_array_gather_v2(handle, indices, flow_in, dtype: nil, element_shape: [], name: "TensorArrayGatherV2") ⇒ Object 



4507
4508
4509
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4507

def self.tensor_array_gather_v2(handle, indices, flow_in, dtype: nil, element_shape: [], name: "TensorArrayGatherV2")
  self.execute("TensorArrayGatherV2", [handle, indices, flow_in], dtype: dtype, element_shape: element_shape, name: name)
end

.tensor_array_gather_v3(handle, indices, flow_in, dtype: nil, element_shape: [], name: "TensorArrayGatherV3") ⇒ Object 



4511
4512
4513
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4511

def self.tensor_array_gather_v3(handle, indices, flow_in, dtype: nil, element_shape: [], name: "TensorArrayGatherV3")
  self.execute("TensorArrayGatherV3", [handle, indices, flow_in], dtype: dtype, element_shape: element_shape, name: name)
end

.tensor_array_grad(handle, flow_in, source: "", name: "TensorArrayGrad") ⇒ Object 



4515
4516
4517
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4515

def self.tensor_array_grad(handle, flow_in, source: "", name: "TensorArrayGrad")
  self.execute("TensorArrayGrad", [handle, flow_in], source: source, name: name)
end

.tensor_array_grad_v2(handle, flow_in, source: "", name: "TensorArrayGradV2") ⇒ Object 



4519
4520
4521
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4519

def self.tensor_array_grad_v2(handle, flow_in, source: "", name: "TensorArrayGradV2")
  self.execute("TensorArrayGradV2", [handle, flow_in], source: source, name: name)
end

.tensor_array_grad_v3(handle, flow_in, source: "", name: "TensorArrayGradV3") ⇒ Object 



4523
4524
4525
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4523

def self.tensor_array_grad_v3(handle, flow_in, source: "", name: "TensorArrayGradV3")
  self.execute("TensorArrayGradV3", [handle, flow_in], source: source, name: name)
end

.tensor_array_grad_with_shape(handle, flow_in, shape_to_prepend, source: "", name: "TensorArrayGradWithShape") ⇒ Object 



4527
4528
4529
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4527

def self.tensor_array_grad_with_shape(handle, flow_in, shape_to_prepend, source: "", name: "TensorArrayGradWithShape")
  self.execute("TensorArrayGradWithShape", [handle, flow_in, shape_to_prepend], source: source, name: name)
end

.tensor_array_pack(handle, flow_in, dtype: nil, element_shape: [], name: "TensorArrayPack") ⇒ Object 



4531
4532
4533
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4531

def self.tensor_array_pack(handle, flow_in, dtype: nil, element_shape: [], name: "TensorArrayPack")
  self.execute("TensorArrayPack", [handle, flow_in], dtype: dtype, element_shape: element_shape, name: name)
end

.tensor_array_read(handle, index, flow_in, dtype: nil, name: "TensorArrayRead") ⇒ Object 



4535
4536
4537
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4535

def self.tensor_array_read(handle, index, flow_in, dtype: nil, name: "TensorArrayRead")
  self.execute("TensorArrayRead", [handle, index, flow_in], dtype: dtype, name: name)
end

.tensor_array_read_v2(handle, index, flow_in, dtype: nil, name: "TensorArrayReadV2") ⇒ Object 



4539
4540
4541
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4539

def self.tensor_array_read_v2(handle, index, flow_in, dtype: nil, name: "TensorArrayReadV2")
  self.execute("TensorArrayReadV2", [handle, index, flow_in], dtype: dtype, name: name)
end

.tensor_array_read_v3(handle, index, flow_in, dtype: nil, name: "TensorArrayReadV3") ⇒ Object 



4543
4544
4545
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4543

def self.tensor_array_read_v3(handle, index, flow_in, dtype: nil, name: "TensorArrayReadV3")
  self.execute("TensorArrayReadV3", [handle, index, flow_in], dtype: dtype, name: name)
end

.tensor_array_scatter(handle, indices, value, flow_in, typeT: nil, name: "TensorArrayScatter") ⇒ Object 



4547
4548
4549
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4547

def self.tensor_array_scatter(handle, indices, value, flow_in, typeT: nil, name: "TensorArrayScatter")
  self.execute("TensorArrayScatter", [handle, indices, value, flow_in], T: typeT, name: name)
end

.tensor_array_scatter_v2(handle, indices, value, flow_in, typeT: nil, name: "TensorArrayScatterV2") ⇒ Object 



4551
4552
4553
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4551

def self.tensor_array_scatter_v2(handle, indices, value, flow_in, typeT: nil, name: "TensorArrayScatterV2")
  self.execute("TensorArrayScatterV2", [handle, indices, value, flow_in], T: typeT, name: name)
end

.tensor_array_scatter_v3(handle, indices, value, flow_in, typeT: nil, name: "TensorArrayScatterV3") ⇒ Object 



4555
4556
4557
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4555

def self.tensor_array_scatter_v3(handle, indices, value, flow_in, typeT: nil, name: "TensorArrayScatterV3")
  self.execute("TensorArrayScatterV3", [handle, indices, value, flow_in], T: typeT, name: name)
end

.tensor_array_size(handle, flow_in, name: "TensorArraySize") ⇒ Object 



4559
4560
4561
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4559

def self.tensor_array_size(handle, flow_in, name: "TensorArraySize")
  self.execute("TensorArraySize", [handle, flow_in], name: name)
end

.tensor_array_size_v2(handle, flow_in, name: "TensorArraySizeV2") ⇒ Object 



4563
4564
4565
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4563

def self.tensor_array_size_v2(handle, flow_in, name: "TensorArraySizeV2")
  self.execute("TensorArraySizeV2", [handle, flow_in], name: name)
end

.tensor_array_size_v3(handle, flow_in, name: "TensorArraySizeV3") ⇒ Object 



4567
4568
4569
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4567

def self.tensor_array_size_v3(handle, flow_in, name: "TensorArraySizeV3")
  self.execute("TensorArraySizeV3", [handle, flow_in], name: name)
end

.tensor_array_split(handle, value, lengths, flow_in, typeT: nil, name: "TensorArraySplit") ⇒ Object 



4571
4572
4573
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4571

def self.tensor_array_split(handle, value, lengths, flow_in, typeT: nil, name: "TensorArraySplit")
  self.execute("TensorArraySplit", [handle, value, lengths, flow_in], T: typeT, name: name)
end

.tensor_array_split_v2(handle, value, lengths, flow_in, typeT: nil, name: "TensorArraySplitV2") ⇒ Object 



4575
4576
4577
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4575

def self.tensor_array_split_v2(handle, value, lengths, flow_in, typeT: nil, name: "TensorArraySplitV2")
  self.execute("TensorArraySplitV2", [handle, value, lengths, flow_in], T: typeT, name: name)
end

.tensor_array_split_v3(handle, value, lengths, flow_in, typeT: nil, name: "TensorArraySplitV3") ⇒ Object 



4579
4580
4581
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4579

def self.tensor_array_split_v3(handle, value, lengths, flow_in, typeT: nil, name: "TensorArraySplitV3")
  self.execute("TensorArraySplitV3", [handle, value, lengths, flow_in], T: typeT, name: name)
end

.tensor_array_unpack(handle, value, flow_in, typeT: nil, name: "TensorArrayUnpack") ⇒ Object 



4583
4584
4585
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4583

def self.tensor_array_unpack(handle, value, flow_in, typeT: nil, name: "TensorArrayUnpack")
  self.execute("TensorArrayUnpack", [handle, value, flow_in], T: typeT, name: name)
end

.tensor_array_v2(size, dtype: nil, element_shape: [], dynamic_size: false, clear_after_read: true, tensor_array_name: "", name: "TensorArrayV2") ⇒ Object 



4587
4588
4589
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4587

def self.tensor_array_v2(size, dtype: nil, element_shape: [], dynamic_size: false, clear_after_read: true, tensor_array_name: "", name: "TensorArrayV2")
  self.execute("TensorArrayV2", [size], dtype: dtype, element_shape: element_shape, dynamic_size: dynamic_size, clear_after_read: clear_after_read, tensor_array_name: tensor_array_name, name: name)
end

.tensor_array_v3(size, dtype: nil, element_shape: [], dynamic_size: false, clear_after_read: true, identical_element_shapes: false, tensor_array_name: "", name: "TensorArrayV3") ⇒ Object 



4591
4592
4593
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4591

def self.tensor_array_v3(size, dtype: nil, element_shape: [], dynamic_size: false, clear_after_read: true, identical_element_shapes: false, tensor_array_name: "", name: "TensorArrayV3")
  self.execute("TensorArrayV3", [size], dtype: dtype, element_shape: element_shape, dynamic_size: dynamic_size, clear_after_read: clear_after_read, identical_element_shapes: identical_element_shapes, tensor_array_name: tensor_array_name, name: name)
end

.tensor_array_write(handle, index, value, flow_in, typeT: nil, name: "TensorArrayWrite") ⇒ Object 



4595
4596
4597
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4595

def self.tensor_array_write(handle, index, value, flow_in, typeT: nil, name: "TensorArrayWrite")
  self.execute("TensorArrayWrite", [handle, index, value, flow_in], T: typeT, name: name)
end

.tensor_array_write_v2(handle, index, value, flow_in, typeT: nil, name: "TensorArrayWriteV2") ⇒ Object 



4599
4600
4601
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4599

def self.tensor_array_write_v2(handle, index, value, flow_in, typeT: nil, name: "TensorArrayWriteV2")
  self.execute("TensorArrayWriteV2", [handle, index, value, flow_in], T: typeT, name: name)
end

.tensor_array_write_v3(handle, index, value, flow_in, typeT: nil, name: "TensorArrayWriteV3") ⇒ Object 



4603
4604
4605
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4603

def self.tensor_array_write_v3(handle, index, value, flow_in, typeT: nil, name: "TensorArrayWriteV3")
  self.execute("TensorArrayWriteV3", [handle, index, value, flow_in], T: typeT, name: name)
end

.tensor_dataset(components, toutput_types: nil, output_shapes: nil, name: "TensorDataset") ⇒ Object 



4607
4608
4609
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4607

def self.tensor_dataset(components, toutput_types: nil, output_shapes: nil, name: "TensorDataset")
  self.execute("TensorDataset", [components], Toutput_types: toutput_types, output_shapes: output_shapes, name: name)
end

.tensor_forest_create_tree_variable(tree_handle, tree_config, name: "TensorForestCreateTreeVariable") ⇒ Object 



4611
4612
4613
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4611

def self.tensor_forest_create_tree_variable(tree_handle, tree_config, name: "TensorForestCreateTreeVariable")
  self.execute("TensorForestCreateTreeVariable", [tree_handle, tree_config], name: name)
end

.tensor_forest_tree_deserialize(tree_handle, tree_config, name: "TensorForestTreeDeserialize") ⇒ Object 



4615
4616
4617
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4615

def self.tensor_forest_tree_deserialize(tree_handle, tree_config, name: "TensorForestTreeDeserialize")
  self.execute("TensorForestTreeDeserialize", [tree_handle, tree_config], name: name)
end

.tensor_forest_tree_is_initialized_op(tree_handle, name: "TensorForestTreeIsInitializedOp") ⇒ Object 



4619
4620
4621
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4619

def self.tensor_forest_tree_is_initialized_op(tree_handle, name: "TensorForestTreeIsInitializedOp")
  self.execute("TensorForestTreeIsInitializedOp", [tree_handle], name: name)
end

.tensor_forest_tree_predict(tree_handle, dense_features, logits_dimension: nil, name: "TensorForestTreePredict") ⇒ Object 



4623
4624
4625
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4623

def self.tensor_forest_tree_predict(tree_handle, dense_features, logits_dimension: nil, name: "TensorForestTreePredict")
  self.execute("TensorForestTreePredict", [tree_handle, dense_features], logits_dimension: logits_dimension, name: name)
end

.tensor_forest_tree_resource_handle_op(container: "", shared_name: "", name: "TensorForestTreeResourceHandleOp") ⇒ Object 



4627
4628
4629
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4627

def self.tensor_forest_tree_resource_handle_op(container: "", shared_name: "", name: "TensorForestTreeResourceHandleOp")
  self.execute("TensorForestTreeResourceHandleOp", [], container: container, shared_name: shared_name, name: name)
end

.tensor_forest_tree_serialize(tree_handle, name: "TensorForestTreeSerialize") ⇒ Object 



4631
4632
4633
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4631

def self.tensor_forest_tree_serialize(tree_handle, name: "TensorForestTreeSerialize")
  self.execute("TensorForestTreeSerialize", [tree_handle], name: name)
end

.tensor_forest_tree_size(tree_handle, name: "TensorForestTreeSize") ⇒ Object 



4635
4636
4637
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4635

def self.tensor_forest_tree_size(tree_handle, name: "TensorForestTreeSize")
  self.execute("TensorForestTreeSize", [tree_handle], name: name)
end

.tensor_list_concat(input_handle, element_dtype: nil, element_shape: [], name: "TensorListConcat") ⇒ Object 



4639
4640
4641
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4639

def self.tensor_list_concat(input_handle, element_dtype: nil, element_shape: [], name: "TensorListConcat")
  self.execute("TensorListConcat", [input_handle], element_dtype: element_dtype, element_shape: element_shape, name: name)
end

.tensor_list_concat_lists(input_a, input_b, element_dtype: nil, name: "TensorListConcatLists") ⇒ Object 



4643
4644
4645
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4643

def self.tensor_list_concat_lists(input_a, input_b, element_dtype: nil, name: "TensorListConcatLists")
  self.execute("TensorListConcatLists", [input_a, input_b], element_dtype: element_dtype, name: name)
end

.tensor_list_concat_v2(input_handle, element_shape, leading_dims, element_dtype: nil, shape_type: nil, name: "TensorListConcatV2") ⇒ Object 



4647
4648
4649
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4647

def self.tensor_list_concat_v2(input_handle, element_shape, leading_dims, element_dtype: nil, shape_type: nil, name: "TensorListConcatV2")
  self.execute("TensorListConcatV2", [input_handle, element_shape, leading_dims], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.tensor_list_element_shape(input_handle, shape_type: nil, name: "TensorListElementShape") ⇒ Object 



4651
4652
4653
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4651

def self.tensor_list_element_shape(input_handle, shape_type: nil, name: "TensorListElementShape")
  self.execute("TensorListElementShape", [input_handle], shape_type: shape_type, name: name)
end

.tensor_list_from_tensor(tensor, element_shape, element_dtype: nil, shape_type: nil, name: "TensorListFromTensor") ⇒ Object 



4655
4656
4657
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4655

def self.tensor_list_from_tensor(tensor, element_shape, element_dtype: nil, shape_type: nil, name: "TensorListFromTensor")
  self.execute("TensorListFromTensor", [tensor, element_shape], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.tensor_list_gather(input_handle, indices, element_shape, element_dtype: nil, name: "TensorListGather") ⇒ Object 



4659
4660
4661
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4659

def self.tensor_list_gather(input_handle, indices, element_shape, element_dtype: nil, name: "TensorListGather")
  self.execute("TensorListGather", [input_handle, indices, element_shape], element_dtype: element_dtype, name: name)
end

.tensor_list_get_item(input_handle, index, element_shape, element_dtype: nil, name: "TensorListGetItem") ⇒ Object 



4663
4664
4665
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4663

def self.tensor_list_get_item(input_handle, index, element_shape, element_dtype: nil, name: "TensorListGetItem")
  self.execute("TensorListGetItem", [input_handle, index, element_shape], element_dtype: element_dtype, name: name)
end

.tensor_list_length(input_handle, name: "TensorListLength") ⇒ Object 



4667
4668
4669
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4667

def self.tensor_list_length(input_handle, name: "TensorListLength")
  self.execute("TensorListLength", [input_handle], name: name)
end

.tensor_list_pop_back(input_handle, element_shape, element_dtype: nil, name: "TensorListPopBack") ⇒ Object 



4671
4672
4673
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4671

def self.tensor_list_pop_back(input_handle, element_shape, element_dtype: nil, name: "TensorListPopBack")
  self.execute("TensorListPopBack", [input_handle, element_shape], element_dtype: element_dtype, name: name)
end

.tensor_list_push_back(input_handle, tensor, element_dtype: nil, name: "TensorListPushBack") ⇒ Object 



4675
4676
4677
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4675

def self.tensor_list_push_back(input_handle, tensor, element_dtype: nil, name: "TensorListPushBack")
  self.execute("TensorListPushBack", [input_handle, tensor], element_dtype: element_dtype, name: name)
end

.tensor_list_push_back_batch(input_handles, tensor, element_dtype: nil, name: "TensorListPushBackBatch") ⇒ Object 



4679
4680
4681
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4679

def self.tensor_list_push_back_batch(input_handles, tensor, element_dtype: nil, name: "TensorListPushBackBatch")
  self.execute("TensorListPushBackBatch", [input_handles, tensor], element_dtype: element_dtype, name: name)
end

.tensor_list_reserve(element_shape, num_elements, element_dtype: nil, shape_type: nil, name: "TensorListReserve") ⇒ Object 



4683
4684
4685
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4683

def self.tensor_list_reserve(element_shape, num_elements, element_dtype: nil, shape_type: nil, name: "TensorListReserve")
  self.execute("TensorListReserve", [element_shape, num_elements], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.tensor_list_resize(input_handle, size, name: "TensorListResize") ⇒ Object 



4687
4688
4689
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4687

def self.tensor_list_resize(input_handle, size, name: "TensorListResize")
  self.execute("TensorListResize", [input_handle, size], name: name)
end

.tensor_list_scatter(tensor, indices, element_shape, element_dtype: nil, shape_type: nil, name: "TensorListScatter") ⇒ Object 



4691
4692
4693
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4691

def self.tensor_list_scatter(tensor, indices, element_shape, element_dtype: nil, shape_type: nil, name: "TensorListScatter")
  self.execute("TensorListScatter", [tensor, indices, element_shape], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.tensor_list_scatter_into_existing_list(input_handle, tensor, indices, element_dtype: nil, name: "TensorListScatterIntoExistingList") ⇒ Object 



4695
4696
4697
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4695

def self.tensor_list_scatter_into_existing_list(input_handle, tensor, indices, element_dtype: nil, name: "TensorListScatterIntoExistingList")
  self.execute("TensorListScatterIntoExistingList", [input_handle, tensor, indices], element_dtype: element_dtype, name: name)
end

.tensor_list_scatter_v2(tensor, indices, element_shape, num_elements, element_dtype: nil, shape_type: nil, name: "TensorListScatterV2") ⇒ Object 



4699
4700
4701
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4699

def self.tensor_list_scatter_v2(tensor, indices, element_shape, num_elements, element_dtype: nil, shape_type: nil, name: "TensorListScatterV2")
  self.execute("TensorListScatterV2", [tensor, indices, element_shape, num_elements], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.tensor_list_set_item(input_handle, index, item, element_dtype: nil, name: "TensorListSetItem") ⇒ Object 



4703
4704
4705
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4703

def self.tensor_list_set_item(input_handle, index, item, element_dtype: nil, name: "TensorListSetItem")
  self.execute("TensorListSetItem", [input_handle, index, item], element_dtype: element_dtype, name: name)
end

.tensor_list_split(tensor, element_shape, lengths, element_dtype: nil, shape_type: nil, name: "TensorListSplit") ⇒ Object 



4707
4708
4709
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4707

def self.tensor_list_split(tensor, element_shape, lengths, element_dtype: nil, shape_type: nil, name: "TensorListSplit")
  self.execute("TensorListSplit", [tensor, element_shape, lengths], element_dtype: element_dtype, shape_type: shape_type, name: name)
end

.tensor_list_stack(input_handle, element_shape, element_dtype: nil, num_elements: -1,, name: "TensorListStack") ⇒ Object 



4711
4712
4713
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4711

def self.tensor_list_stack(input_handle, element_shape, element_dtype: nil, num_elements: -1, name: "TensorListStack")
  self.execute("TensorListStack", [input_handle, element_shape], element_dtype: element_dtype, num_elements: num_elements, name: name)
end

.tensor_scatter_add(tensor, indices, updates, typeT: nil, tindices: nil, name: "TensorScatterAdd") ⇒ Object 



4715
4716
4717
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4715

def self.tensor_scatter_add(tensor, indices, updates, typeT: nil, tindices: nil, name: "TensorScatterAdd")
  self.execute("TensorScatterAdd", [tensor, indices, updates], T: typeT, Tindices: tindices, name: name)
end

.tensor_scatter_sub(tensor, indices, updates, typeT: nil, tindices: nil, name: "TensorScatterSub") ⇒ Object 



4719
4720
4721
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4719

def self.tensor_scatter_sub(tensor, indices, updates, typeT: nil, tindices: nil, name: "TensorScatterSub")
  self.execute("TensorScatterSub", [tensor, indices, updates], T: typeT, Tindices: tindices, name: name)
end

.tensor_scatter_update(tensor, indices, updates, typeT: nil, tindices: nil, name: "TensorScatterUpdate") ⇒ Object 



4723
4724
4725
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4723

def self.tensor_scatter_update(tensor, indices, updates, typeT: nil, tindices: nil, name: "TensorScatterUpdate")
  self.execute("TensorScatterUpdate", [tensor, indices, updates], T: typeT, Tindices: tindices, name: name)
end

.tensor_slice_dataset(components, toutput_types: nil, output_shapes: nil, name: "TensorSliceDataset") ⇒ Object 



4727
4728
4729
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4727

def self.tensor_slice_dataset(components, toutput_types: nil, output_shapes: nil, name: "TensorSliceDataset")
  self.execute("TensorSliceDataset", [components], Toutput_types: toutput_types, output_shapes: output_shapes, name: name)
end

.tensor_strided_slice_update(input, start, stop, strides, value, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "TensorStridedSliceUpdate") ⇒ Object 



4731
4732
4733
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4731

def self.tensor_strided_slice_update(input, start, stop, strides, value, typeT: nil, index: nil, begin_mask: 0, end_mask: 0, ellipsis_mask: 0, new_axis_mask: 0, shrink_axis_mask: 0, name: "TensorStridedSliceUpdate")
  self.execute("TensorStridedSliceUpdate", [input, start, stop, strides, value], T: typeT, Index: index, begin_mask: begin_mask, end_mask: end_mask, ellipsis_mask: ellipsis_mask, new_axis_mask: new_axis_mask, shrink_axis_mask: shrink_axis_mask, name: name)
end

.tensor_summary(tensor, typeT: nil, description: "", labels: [], display_name: "", name: "TensorSummary") ⇒ Object 



4735
4736
4737
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4735

def self.tensor_summary(tensor, typeT: nil, description: "", labels: [], display_name: "", name: "TensorSummary")
  self.execute("TensorSummary", [tensor], T: typeT, description: description, labels: labels, display_name: display_name, name: name)
end

.tensor_summary_v2(tag, tensor, serialized_summary_metadata, typeT: nil, name: "TensorSummaryV2") ⇒ Object 



4739
4740
4741
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4739

def self.tensor_summary_v2(tag, tensor, serialized_summary_metadata, typeT: nil, name: "TensorSummaryV2")
  self.execute("TensorSummaryV2", [tag, tensor, serialized_summary_metadata], T: typeT, name: name)
end

.text_line_dataset(filenames, compression_type, buffer_size, name: "TextLineDataset") ⇒ Object 



4743
4744
4745
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4743

def self.text_line_dataset(filenames, compression_type, buffer_size, name: "TextLineDataset")
  self.execute("TextLineDataset", [filenames, compression_type, buffer_size], name: name)
end

.text_line_reader(skip_header_lines: 0, container: "", shared_name: "", name: "TextLineReader") ⇒ Object 



4747
4748
4749
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4747

def self.text_line_reader(skip_header_lines: 0, container: "", shared_name: "", name: "TextLineReader")
  self.execute("TextLineReader", [], skip_header_lines: skip_header_lines, container: container, shared_name: shared_name, name: name)
end

.text_line_reader_v2(skip_header_lines: 0, container: "", shared_name: "", name: "TextLineReaderV2") ⇒ Object 



4751
4752
4753
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4751

def self.text_line_reader_v2(skip_header_lines: 0, container: "", shared_name: "", name: "TextLineReaderV2")
  self.execute("TextLineReaderV2", [], skip_header_lines: skip_header_lines, container: container, shared_name: shared_name, name: name)
end

.tf_record_dataset(filenames, compression_type, buffer_size, name: "TFRecordDataset") ⇒ Object 



4407
4408
4409
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4407

def self.tf_record_dataset(filenames, compression_type, buffer_size, name: "TFRecordDataset")
  self.execute("TFRecordDataset", [filenames, compression_type, buffer_size], name: name)
end

.tf_record_reader(container: "", shared_name: "", compression_type: "", name: "TFRecordReader") ⇒ Object 



4411
4412
4413
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4411

def self.tf_record_reader(container: "", shared_name: "", compression_type: "", name: "TFRecordReader")
  self.execute("TFRecordReader", [], container: container, shared_name: shared_name, compression_type: compression_type, name: name)
end

.tf_record_reader_v2(container: "", shared_name: "", compression_type: "", name: "TFRecordReaderV2") ⇒ Object 



4415
4416
4417
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4415

def self.tf_record_reader_v2(container: "", shared_name: "", compression_type: "", name: "TFRecordReaderV2")
  self.execute("TFRecordReaderV2", [], container: container, shared_name: shared_name, compression_type: compression_type, name: name)
end

.thread_pool_dataset(input_dataset, thread_pool, output_types: nil, output_shapes: nil, name: "ThreadPoolDataset") ⇒ Object 



4755
4756
4757
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4755

def self.thread_pool_dataset(input_dataset, thread_pool, output_types: nil, output_shapes: nil, name: "ThreadPoolDataset")
  self.execute("ThreadPoolDataset", [input_dataset, thread_pool], output_types: output_types, output_shapes: output_shapes, name: name)
end

.thread_pool_handle(num_threads: nil, max_intra_op_parallelism: 1, display_name: "", container: "", shared_name: "", name: "ThreadPoolHandle") ⇒ Object 



4759
4760
4761
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4759

def self.thread_pool_handle(num_threads: nil, max_intra_op_parallelism: 1, display_name: "", container: "", shared_name: "", name: "ThreadPoolHandle")
  self.execute("ThreadPoolHandle", [], num_threads: num_threads, max_intra_op_parallelism: max_intra_op_parallelism, display_name: display_name, container: container, shared_name: shared_name, name: name)
end

.thread_unsafe_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "ThreadUnsafeUnigramCandidateSampler") ⇒ Object 



4763
4764
4765
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4763

def self.thread_unsafe_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "ThreadUnsafeUnigramCandidateSampler")
  self.execute("ThreadUnsafeUnigramCandidateSampler", [true_classes], num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, seed: seed, seed2: seed2, name: name)
end

.tile(input, multiples, typeT: nil, tmultiples: :int32, name: "Tile") ⇒ Object 



4767
4768
4769
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4767

def self.tile(input, multiples, typeT: nil, tmultiples: :int32, name: "Tile")
  self.execute("Tile", [input, multiples], T: typeT, Tmultiples: tmultiples, name: name)
end

.tile_grad(input, multiples, typeT: nil, name: "TileGrad") ⇒ Object 



4771
4772
4773
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4771

def self.tile_grad(input, multiples, typeT: nil, name: "TileGrad")
  self.execute("TileGrad", [input, multiples], T: typeT, name: name)
end

.timestamp(name: "Timestamp") ⇒ Object 



4775
4776
4777
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4775

def self.timestamp(name: "Timestamp")
  self.execute("Timestamp", [], name: name)
end

.top_k(input, k: nil, sorted: true, typeT: nil, name: "TopK") ⇒ Object 



4779
4780
4781
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4779

def self.top_k(input, k: nil, sorted: true, typeT: nil, name: "TopK")
  self.execute("TopK", [input], k: k, sorted: sorted, T: typeT, name: name)
end

.top_kv2(input, k, sorted: true, typeT: nil, name: "TopKV2") ⇒ Object 



4783
4784
4785
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4783

def self.top_kv2(input, k, sorted: true, typeT: nil, name: "TopKV2")
  self.execute("TopKV2", [input, k], sorted: sorted, T: typeT, name: name)
end

.tpu_compilation_result(name: "TPUCompilationResult") ⇒ Object 



4419
4420
4421
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4419

def self.tpu_compilation_result(name: "TPUCompilationResult")
  self.execute("TPUCompilationResult", [], name: name)
end

.tpu_embedding_activations(embedding_variable, sliced_activations, table_id: nil, lookup_id: nil, name: "TPUEmbeddingActivations") ⇒ Object 



4423
4424
4425
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4423

def self.tpu_embedding_activations(embedding_variable, sliced_activations, table_id: nil, lookup_id: nil, name: "TPUEmbeddingActivations")
  self.execute("TPUEmbeddingActivations", [embedding_variable, sliced_activations], table_id: table_id, lookup_id: lookup_id, name: name)
end

.tpu_ordinal_selector(name: "TPUOrdinalSelector") ⇒ Object 



4427
4428
4429
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4427

def self.tpu_ordinal_selector(name: "TPUOrdinalSelector")
  self.execute("TPUOrdinalSelector", [], name: name)
end

.tpu_partitioned_call(args, device_ordinal, tin: nil, tout: nil, f: nil, autotuner_thresh: 0, name: "TPUPartitionedCall") ⇒ Object 



4431
4432
4433
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4431

def self.tpu_partitioned_call(args, device_ordinal, tin: nil, tout: nil, f: nil, autotuner_thresh: 0, name: "TPUPartitionedCall")
  self.execute("TPUPartitionedCall", [args, device_ordinal], Tin: tin, Tout: tout, f: f, autotuner_thresh: autotuner_thresh, name: name)
end

.tpu_replicate_metadata(num_replicas: nil, num_cores_per_replica: 1, topology: "", use_tpu: true, device_assignment: [], computation_shape: [], host_compute_core: [], padding_map: [], step_marker_location: "STEP_MARK_AT_ENTRY", allow_soft_placement: false, name: "TPUReplicateMetadata") ⇒ Object 



4435
4436
4437
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4435

def self.tpu_replicate_metadata(num_replicas: nil, num_cores_per_replica: 1, topology: "", use_tpu: true, device_assignment: [], computation_shape: [], host_compute_core: [], padding_map: [], step_marker_location: "STEP_MARK_AT_ENTRY", allow_soft_placement: false, name: "TPUReplicateMetadata")
  self.execute("TPUReplicateMetadata", [], num_replicas: num_replicas, num_cores_per_replica: num_cores_per_replica, topology: topology, use_tpu: use_tpu, device_assignment: device_assignment, computation_shape: computation_shape, host_compute_core: host_compute_core, padding_map: padding_map, step_marker_location: step_marker_location, allow_soft_placement: allow_soft_placement, name: name)
end

.tpu_replicated_input(inputs, n: nil, typeT: nil, is_mirrored_variable: false, index: -1,, name: "TPUReplicatedInput") ⇒ Object 



4439
4440
4441
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4439

def self.tpu_replicated_input(inputs, n: nil, typeT: nil, is_mirrored_variable: false, index: -1, name: "TPUReplicatedInput")
  self.execute("TPUReplicatedInput", [inputs], N: n, T: typeT, is_mirrored_variable: is_mirrored_variable, index: index, name: name)
end

.tpu_replicated_output(input, num_replicas: nil, typeT: nil, name: "TPUReplicatedOutput") ⇒ Object 



4443
4444
4445
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4443

def self.tpu_replicated_output(input, num_replicas: nil, typeT: nil, name: "TPUReplicatedOutput")
  self.execute("TPUReplicatedOutput", [input], num_replicas: num_replicas, T: typeT, name: name)
end

.transpose(x, perm, typeT: nil, tperm: :int32, name: "Transpose") ⇒ Object 



4787
4788
4789
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4787

def self.transpose(x, perm, typeT: nil, tperm: :int32, name: "Transpose")
  self.execute("Transpose", [x, perm], T: typeT, Tperm: tperm, name: name)
end

.tridiagonal_mat_mul(superdiag, maindiag, subdiag, rhs, typeT: nil, name: "TridiagonalMatMul") ⇒ Object 



4791
4792
4793
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4791

def self.tridiagonal_mat_mul(superdiag, maindiag, subdiag, rhs, typeT: nil, name: "TridiagonalMatMul")
  self.execute("TridiagonalMatMul", [superdiag, maindiag, subdiag, rhs], T: typeT, name: name)
end

.tridiagonal_solve(diagonals, rhs, partial_pivoting: true, typeT: nil, name: "TridiagonalSolve") ⇒ Object 



4795
4796
4797
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4795

def self.tridiagonal_solve(diagonals, rhs, partial_pivoting: true, typeT: nil, name: "TridiagonalSolve")
  self.execute("TridiagonalSolve", [diagonals, rhs], partial_pivoting: partial_pivoting, T: typeT, name: name)
end

.truncate_div(x, y, typeT: nil, name: "TruncateDiv") ⇒ Object 



4799
4800
4801
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4799

def self.truncate_div(x, y, typeT: nil, name: "TruncateDiv")
  self.execute("TruncateDiv", [x, y], T: typeT, name: name)
end

.truncate_mod(x, y, typeT: nil, name: "TruncateMod") ⇒ Object 



4803
4804
4805
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4803

def self.truncate_mod(x, y, typeT: nil, name: "TruncateMod")
  self.execute("TruncateMod", [x, y], T: typeT, name: name)
end

.truncated_normal(shape, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "TruncatedNormal") ⇒ Object 



4807
4808
4809
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4807

def self.truncated_normal(shape, seed: 0, seed2: 0, dtype: nil, typeT: nil, name: "TruncatedNormal")
  self.execute("TruncatedNormal", [shape], seed: seed, seed2: seed2, dtype: dtype, T: typeT, name: name)
end

.try_rpc(address, method, request, protocol: "", fail_fast: true, timeout_in_ms: 0, name: "TryRpc") ⇒ Object 



4811
4812
4813
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4811

def self.try_rpc(address, method, request, protocol: "", fail_fast: true, timeout_in_ms: 0, name: "TryRpc")
  self.execute("TryRpc", [address, method, request], protocol: protocol, fail_fast: fail_fast, timeout_in_ms: timeout_in_ms, name: name)
end

.unbatch(batched_tensor, batch_index, id, timeout_micros: nil, container: "", shared_name: "", typeT: nil, name: "Unbatch") ⇒ Object 



4815
4816
4817
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4815

def self.unbatch(batched_tensor, batch_index, id, timeout_micros: nil, container: "", shared_name: "", typeT: nil, name: "Unbatch")
  self.execute("Unbatch", [batched_tensor, batch_index, id], timeout_micros: timeout_micros, container: container, shared_name: shared_name, T: typeT, name: name)
end

.unbatch_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "UnbatchDataset") ⇒ Object 



4819
4820
4821
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4819

def self.unbatch_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "UnbatchDataset")
  self.execute("UnbatchDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.unbatch_grad(original_input, batch_index, grad, id, container: "", shared_name: "", typeT: nil, name: "UnbatchGrad") ⇒ Object 



4823
4824
4825
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4823

def self.unbatch_grad(original_input, batch_index, grad, id, container: "", shared_name: "", typeT: nil, name: "UnbatchGrad")
  self.execute("UnbatchGrad", [original_input, batch_index, grad, id], container: container, shared_name: shared_name, T: typeT, name: name)
end

.unicode_decode(input, input_encoding: "", errors: "replace", replacement_char: 65533, replace_control_characters: false, tsplits: :int64, name: "UnicodeDecode") ⇒ Object 



4827
4828
4829
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4827

def self.unicode_decode(input, input_encoding: "", errors: "replace", replacement_char: 65533, replace_control_characters: false, tsplits: :int64, name: "UnicodeDecode")
  self.execute("UnicodeDecode", [input], input_encoding: input_encoding, errors: errors, replacement_char: replacement_char, replace_control_characters: replace_control_characters, Tsplits: tsplits, name: name)
end

.unicode_decode_with_offsets(input, input_encoding: "", errors: "replace", replacement_char: 65533, replace_control_characters: false, tsplits: :int64, name: "UnicodeDecodeWithOffsets") ⇒ Object 



4831
4832
4833
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4831

def self.unicode_decode_with_offsets(input, input_encoding: "", errors: "replace", replacement_char: 65533, replace_control_characters: false, tsplits: :int64, name: "UnicodeDecodeWithOffsets")
  self.execute("UnicodeDecodeWithOffsets", [input], input_encoding: input_encoding, errors: errors, replacement_char: replacement_char, replace_control_characters: replace_control_characters, Tsplits: tsplits, name: name)
end

.unicode_encode(input_values, input_splits, errors: "replace", output_encoding: nil, replacement_char: 65533, tsplits: :int64, name: "UnicodeEncode") ⇒ Object 



4835
4836
4837
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4835

def self.unicode_encode(input_values, input_splits, errors: "replace", output_encoding: nil, replacement_char: 65533, tsplits: :int64, name: "UnicodeEncode")
  self.execute("UnicodeEncode", [input_values, input_splits], errors: errors, output_encoding: output_encoding, replacement_char: replacement_char, Tsplits: tsplits, name: name)
end

.unicode_script(input, name: "UnicodeScript") ⇒ Object 



4839
4840
4841
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4839

def self.unicode_script(input, name: "UnicodeScript")
  self.execute("UnicodeScript", [input], name: name)
end

.unicode_transcode(input, input_encoding: "", output_encoding: nil, errors: "replace", replacement_char: 65533, replace_control_characters: false, name: "UnicodeTranscode") ⇒ Object 



4843
4844
4845
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4843

def self.unicode_transcode(input, input_encoding: "", output_encoding: nil, errors: "replace", replacement_char: 65533, replace_control_characters: false, name: "UnicodeTranscode")
  self.execute("UnicodeTranscode", [input], input_encoding: input_encoding, output_encoding: output_encoding, errors: errors, replacement_char: replacement_char, replace_control_characters: replace_control_characters, name: name)
end

.uniform_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "UniformCandidateSampler") ⇒ Object 



4847
4848
4849
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4847

def self.uniform_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: 0, seed2: 0, name: "UniformCandidateSampler")
  self.execute("UniformCandidateSampler", [true_classes], num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, seed: seed, seed2: seed2, name: name)
end

.unique(x, typeT: nil, out_idx: :int32, name: "Unique") ⇒ Object 



4851
4852
4853
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4851

def self.unique(x, typeT: nil, out_idx: :int32, name: "Unique")
  self.execute("Unique", [x], T: typeT, out_idx: out_idx, name: name)
end

.unique_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "UniqueDataset") ⇒ Object 



4855
4856
4857
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4855

def self.unique_dataset(input_dataset, output_types: nil, output_shapes: nil, name: "UniqueDataset")
  self.execute("UniqueDataset", [input_dataset], output_types: output_types, output_shapes: output_shapes, name: name)
end

.unique_v2(x, axis, typeT: nil, taxis: :int64, out_idx: :int32, name: "UniqueV2") ⇒ Object 



4859
4860
4861
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4859

def self.unique_v2(x, axis, typeT: nil, taxis: :int64, out_idx: :int32, name: "UniqueV2")
  self.execute("UniqueV2", [x, axis], T: typeT, Taxis: taxis, out_idx: out_idx, name: name)
end

.unique_with_counts(x, typeT: nil, out_idx: :int32, name: "UniqueWithCounts") ⇒ Object 



4863
4864
4865
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4863

def self.unique_with_counts(x, typeT: nil, out_idx: :int32, name: "UniqueWithCounts")
  self.execute("UniqueWithCounts", [x], T: typeT, out_idx: out_idx, name: name)
end

.unique_with_counts_v2(x, axis, typeT: nil, taxis: :int64, out_idx: :int32, name: "UniqueWithCountsV2") ⇒ Object 



4867
4868
4869
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4867

def self.unique_with_counts_v2(x, axis, typeT: nil, taxis: :int64, out_idx: :int32, name: "UniqueWithCountsV2")
  self.execute("UniqueWithCountsV2", [x, axis], T: typeT, Taxis: taxis, out_idx: out_idx, name: name)
end

.unpack(value, num: nil, typeT: nil, axis: 0, name: "Unpack") ⇒ Object 



4871
4872
4873
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4871

def self.unpack(value, num: nil, typeT: nil, axis: 0, name: "Unpack")
  self.execute("Unpack", [value], num: num, T: typeT, axis: axis, name: name)
end

.unravel_index(indices, dims, tidx: :int32, name: "UnravelIndex") ⇒ Object 



4875
4876
4877
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4875

def self.unravel_index(indices, dims, tidx: :int32, name: "UnravelIndex")
  self.execute("UnravelIndex", [indices, dims], Tidx: tidx, name: name)
end

.unsorted_segment_join(inputs, segment_ids, num_segments, separator: "", tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentJoin") ⇒ Object 



4879
4880
4881
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4879

def self.unsorted_segment_join(inputs, segment_ids, num_segments, separator: "", tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentJoin")
  self.execute("UnsortedSegmentJoin", [inputs, segment_ids, num_segments], separator: separator, Tindices: tindices, Tnumsegments: tnumsegments, name: name)
end

.unsorted_segment_max(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentMax") ⇒ Object 



4883
4884
4885
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4883

def self.unsorted_segment_max(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentMax")
  self.execute("UnsortedSegmentMax", [data, segment_ids, num_segments], T: typeT, Tindices: tindices, Tnumsegments: tnumsegments, name: name)
end

.unsorted_segment_min(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentMin") ⇒ Object 



4887
4888
4889
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4887

def self.unsorted_segment_min(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentMin")
  self.execute("UnsortedSegmentMin", [data, segment_ids, num_segments], T: typeT, Tindices: tindices, Tnumsegments: tnumsegments, name: name)
end

.unsorted_segment_prod(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentProd") ⇒ Object 



4891
4892
4893
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4891

def self.unsorted_segment_prod(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentProd")
  self.execute("UnsortedSegmentProd", [data, segment_ids, num_segments], T: typeT, Tindices: tindices, Tnumsegments: tnumsegments, name: name)
end

.unsorted_segment_sum(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentSum") ⇒ Object 



4895
4896
4897
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4895

def self.unsorted_segment_sum(data, segment_ids, num_segments, typeT: nil, tindices: nil, tnumsegments: :int32, name: "UnsortedSegmentSum")
  self.execute("UnsortedSegmentSum", [data, segment_ids, num_segments], T: typeT, Tindices: tindices, Tnumsegments: tnumsegments, name: name)
end

.unstage(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "Unstage") ⇒ Object 



4899
4900
4901
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4899

def self.unstage(capacity: 0, memory_limit: 0, dtypes: nil, container: "", shared_name: "", name: "Unstage")
  self.execute("Unstage", [], capacity: capacity, memory_limit: memory_limit, dtypes: dtypes, container: container, shared_name: shared_name, name: name)
end

.unwrap_dataset_variant(input_handle, name: "UnwrapDatasetVariant") ⇒ Object 



4903
4904
4905
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4903

def self.unwrap_dataset_variant(input_handle, name: "UnwrapDatasetVariant")
  self.execute("UnwrapDatasetVariant", [input_handle], name: name)
end

.upper_bound(sorted_inputs, values, typeT: nil, out_type: :int32, name: "UpperBound") ⇒ Object 



4907
4908
4909
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4907

def self.upper_bound(sorted_inputs, values, typeT: nil, out_type: :int32, name: "UpperBound")
  self.execute("UpperBound", [sorted_inputs, values], T: typeT, out_type: out_type, name: name)
end

.var_handle_op(container: "", shared_name: "", dtype: nil, shape: nil, name: "VarHandleOp") ⇒ Object 



4911
4912
4913
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4911

def self.var_handle_op(container: "", shared_name: "", dtype: nil, shape: nil, name: "VarHandleOp")
  self.execute("VarHandleOp", [], container: container, shared_name: shared_name, dtype: dtype, shape: shape, name: name)
end

.var_is_initialized_op(resource, name: "VarIsInitializedOp") ⇒ Object 



4915
4916
4917
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4915

def self.var_is_initialized_op(resource, name: "VarIsInitializedOp")
  self.execute("VarIsInitializedOp", [resource], name: name)
end

.variable(shape: nil, dtype: nil, container: "", shared_name: "", name: "Variable") ⇒ Object 



4919
4920
4921
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4919

def self.variable(shape: nil, dtype: nil, container: "", shared_name: "", name: "Variable")
  self.execute("Variable", [], shape: shape, dtype: dtype, container: container, shared_name: shared_name, name: name)
end

.variable_shape(input, out_type: :int32, name: "VariableShape") ⇒ Object 



4923
4924
4925
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4923

def self.variable_shape(input, out_type: :int32, name: "VariableShape")
  self.execute("VariableShape", [input], out_type: out_type, name: name)
end

.variable_v2(shape: nil, dtype: nil, container: "", shared_name: "", name: "VariableV2") ⇒ Object 



4927
4928
4929
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4927

def self.variable_v2(shape: nil, dtype: nil, container: "", shared_name: "", name: "VariableV2")
  self.execute("VariableV2", [], shape: shape, dtype: dtype, container: container, shared_name: shared_name, name: name)
end

.where(input, typeT: :bool, name: "Where") ⇒ Object 



4931
4932
4933
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4931

def self.where(input, typeT: :bool, name: "Where")
  self.execute("Where", [input], T: typeT, name: name)
end

.while(input, typeT: nil, cond: nil, body: nil, output_shapes: [], parallel_iterations: 10, name: "While") ⇒ Object 



4935
4936
4937
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4935

def self.while(input, typeT: nil, cond: nil, body: nil, output_shapes: [], parallel_iterations: 10, name: "While")
  self.execute("While", [input], T: typeT, cond: cond, body: body, output_shapes: output_shapes, parallel_iterations: parallel_iterations, name: name)
end

.whole_file_reader(container: "", shared_name: "", name: "WholeFileReader") ⇒ Object 



4939
4940
4941
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4939

def self.whole_file_reader(container: "", shared_name: "", name: "WholeFileReader")
  self.execute("WholeFileReader", [], container: container, shared_name: shared_name, name: name)
end

.whole_file_reader_v2(container: "", shared_name: "", name: "WholeFileReaderV2") ⇒ Object 



4943
4944
4945
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4943

def self.whole_file_reader_v2(container: "", shared_name: "", name: "WholeFileReaderV2")
  self.execute("WholeFileReaderV2", [], container: container, shared_name: shared_name, name: name)
end

.window_dataset(input_dataset, size, shift, stride, drop_remainder, output_types: nil, output_shapes: nil, name: "WindowDataset") ⇒ Object 



4947
4948
4949
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4947

def self.window_dataset(input_dataset, size, shift, stride, drop_remainder, output_types: nil, output_shapes: nil, name: "WindowDataset")
  self.execute("WindowDataset", [input_dataset, size, shift, stride, drop_remainder], output_types: output_types, output_shapes: output_shapes, name: name)
end

.worker_heartbeat(request, name: "WorkerHeartbeat") ⇒ Object 



4951
4952
4953
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4951

def self.worker_heartbeat(request, name: "WorkerHeartbeat")
  self.execute("WorkerHeartbeat", [request], name: name)
end

.wrap_dataset_variant(input_handle, name: "WrapDatasetVariant") ⇒ Object 



4955
4956
4957
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4955

def self.wrap_dataset_variant(input_handle, name: "WrapDatasetVariant")
  self.execute("WrapDatasetVariant", [input_handle], name: name)
end

.write_audio_summary(writer, step, tag, tensor, sample_rate, max_outputs: 3, name: "WriteAudioSummary") ⇒ Object 



4959
4960
4961
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4959

def self.write_audio_summary(writer, step, tag, tensor, sample_rate, max_outputs: 3, name: "WriteAudioSummary")
  self.execute("WriteAudioSummary", [writer, step, tag, tensor, sample_rate], max_outputs: max_outputs, name: name)
end

.write_file(filename, contents, name: "WriteFile") ⇒ Object 



4963
4964
4965
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4963

def self.write_file(filename, contents, name: "WriteFile")
  self.execute("WriteFile", [filename, contents], name: name)
end

.write_graph_summary(writer, step, tensor, name: "WriteGraphSummary") ⇒ Object 



4967
4968
4969
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4967

def self.write_graph_summary(writer, step, tensor, name: "WriteGraphSummary")
  self.execute("WriteGraphSummary", [writer, step, tensor], name: name)
end

.write_histogram_summary(writer, step, tag, values, typeT: :float, name: "WriteHistogramSummary") ⇒ Object 



4971
4972
4973
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4971

def self.write_histogram_summary(writer, step, tag, values, typeT: :float, name: "WriteHistogramSummary")
  self.execute("WriteHistogramSummary", [writer, step, tag, values], T: typeT, name: name)
end

.write_image_summary(writer, step, tag, tensor, bad_color, max_images: 3, typeT: :float, name: "WriteImageSummary") ⇒ Object 



4975
4976
4977
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4975

def self.write_image_summary(writer, step, tag, tensor, bad_color, max_images: 3, typeT: :float, name: "WriteImageSummary")
  self.execute("WriteImageSummary", [writer, step, tag, tensor, bad_color], max_images: max_images, T: typeT, name: name)
end

.write_raw_proto_summary(writer, step, tensor, name: "WriteRawProtoSummary") ⇒ Object 



4979
4980
4981
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4979

def self.write_raw_proto_summary(writer, step, tensor, name: "WriteRawProtoSummary")
  self.execute("WriteRawProtoSummary", [writer, step, tensor], name: name)
end

.write_scalar_summary(writer, step, tag, value, typeT: nil, name: "WriteScalarSummary") ⇒ Object 



4983
4984
4985
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4983

def self.write_scalar_summary(writer, step, tag, value, typeT: nil, name: "WriteScalarSummary")
  self.execute("WriteScalarSummary", [writer, step, tag, value], T: typeT, name: name)
end

.write_summary(writer, step, tensor, tag, summary_metadata, typeT: nil, name: "WriteSummary") ⇒ Object 



4987
4988
4989
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4987

def self.write_summary(writer, step, tensor, tag, summary_metadata, typeT: nil, name: "WriteSummary")
  self.execute("WriteSummary", [writer, step, tensor, tag, summary_metadata], T: typeT, name: name)
end

.xdivy(x, y, typeT: nil, name: "Xdivy") ⇒ Object 



4991
4992
4993
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4991

def self.xdivy(x, y, typeT: nil, name: "Xdivy")
  self.execute("Xdivy", [x, y], T: typeT, name: name)
end

.xlogy(x, y, typeT: nil, name: "Xlogy") ⇒ Object 



4995
4996
4997
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4995

def self.xlogy(x, y, typeT: nil, name: "Xlogy")
  self.execute("Xlogy", [x, y], T: typeT, name: name)
end

.zeros_like(x, typeT: nil, name: "ZerosLike") ⇒ Object 



4999
5000
5001
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 4999

def self.zeros_like(x, typeT: nil, name: "ZerosLike")
  self.execute("ZerosLike", [x], T: typeT, name: name)
end

.zeta(x, q, typeT: nil, name: "Zeta") ⇒ Object 



5003
5004
5005
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5003

def self.zeta(x, q, typeT: nil, name: "Zeta")
  self.execute("Zeta", [x, q], T: typeT, name: name)
end

.zip_dataset(input_datasets, output_types: nil, output_shapes: nil, n: nil, name: "ZipDataset") ⇒ Object 



5007
5008
5009
 
# File 'lib/tensorflow/ops/raw_ops.rb', line 5007

def self.zip_dataset(input_datasets, output_types: nil, output_shapes: nil, n: nil, name: "ZipDataset")
  self.execute("ZipDataset", [input_datasets], output_types: output_types, output_shapes: output_shapes, N: n, name: name)
end