tensorflow 0.0.6 · OCaml Package

module Op_names : sig ... end

val abort : 
  ?name:string ->
  ?error_msg:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `unit ] Node.t

val abs : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val acos : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val add : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 | `string ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val addN : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t list ->
  'a Node.t

val adjustContrast : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t

val adjustContrastv2 : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t

val all : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `int32 ] Node.t ->
  [ `bool ] Node.t

val allCandidateSampler : 
  ?name:string ->
  num_true:int ->
  num_sampled:int ->
  unique:bool ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `float ] Node.t * [ `float ] Node.t

val any : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `int32 ] Node.t ->
  [ `bool ] Node.t

val applyAdadelta : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyAdagrad : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyAdam : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyFtrl : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyGradientDescent : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyMomentum : 
  ?name:string ->
  ?use_locking:bool ->
  ?use_nesterov:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyProximalAdagrad : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyProximalGradientDescent : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val applyRMSProp : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val argMax : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int64 ] Node.t

val argMin : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int64 ] Node.t

val asString : 
  ?name:string ->
  ?precision:int ->
  ?scientific:bool ->
  ?shortest:bool ->
  ?width:int ->
  ?fill:string ->
  ?control_inputs:Node.p list ->
  [< `bool | `complex64 | `double | `float | `int32 | `int64 ] Node.t ->
  [ `string ] Node.t

val asin : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val assign : 
  ?name:string ->
  ?validate_shape:bool ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t ->
  't Node.t

val assignAdd : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val assignSub : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val atan : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val audioSummary : 
  ?name:string ->
  sample_rate:float ->
  ?max_outputs:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `float ] Node.t ->
  [ `string ] Node.t

val avgPool : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val avgPool3D : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val avgPool3DGrad : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val avgPoolGrad : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val barrier : 
  ?name:string ->
  component_types:Node.Type.p list ->
  ?shapes:Node.Dim.t list list ->
  ?capacity:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val barrierClose : 
  ?name:string ->
  ?cancel_pending_enqueues:bool ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val barrierIncompleteSize : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t

val barrierInsertMany : 
  ?name:string ->
  component_index:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  't Node.t ->
  [ `unit ] Node.t

val barrierReadySize : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t

val batchCholesky : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val batchCholeskyGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val batchFFT : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val batchFFT2D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val batchFFT3D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val batchIFFT : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val batchIFFT2D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val batchIFFT3D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val batchMatMul : 
  ?name:string ->
  ?adj_x:bool ->
  ?adj_y:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val batchMatrixBandPart : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  't Node.t

val batchMatrixDeterminant : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val batchMatrixDiag : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val batchMatrixDiagPart : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val batchMatrixInverse : 
  ?name:string ->
  ?adjoint:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val batchMatrixSetDiag : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t ->
  't Node.t

val batchMatrixSolve : 
  ?name:string ->
  ?adjoint:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val batchMatrixSolveLs : 
  ?name:string ->
  ?fast:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  [ `double ] Node.t ->
  'a Node.t

val batchMatrixTriangularSolve : 
  ?name:string ->
  ?lower:bool ->
  ?adjoint:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val batchNormWithGlobalNormalization : 
  ?name:string ->
  variance_epsilon:float ->
  scale_after_normalization:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val batchNormWithGlobalNormalizationGrad : 
  ?name:string ->
  variance_epsilon:float ->
  scale_after_normalization:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t * 'a Node.t * 'a Node.t * 'a Node.t * 'a Node.t

val batchSelfAdjointEig : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val batchSelfAdjointEigV2 : 
  ?name:string ->
  ?compute_v:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t * 'a Node.t

val batchSvd : 
  ?name:string ->
  ?compute_uv:bool ->
  ?full_matrices:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t * 'a Node.t * 'a Node.t

val batchToSpace : 
  ?name:string ->
  block_size:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val biasAdd : 
  ?name:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val biasAddGrad : 
  ?name:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val biasAddV1 : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val bitcast : 
  ?name:string ->
  type_:[< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.Type.t ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] Node.t ->
  'a Node.t

val broadcastGradientArgs : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t * [ `int32 ] Node.t

val cTCGreedyDecoder : 
  ?name:string ->
  ?merge_repeated:bool ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int64 ] Node.t * [ `int64 ] Node.t * [ `int64 ] Node.t * [ `float ] Node.t

val cTCLoss : 
  ?name:string ->
  ?preprocess_collapse_repeated:bool ->
  ?ctc_merge_repeated:bool ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t * [ `float ] Node.t

val ceil : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val checkNumerics : 
  ?name:string ->
  message:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val cholesky : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val choleskyGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val complex : 
  ?name:string ->
  type_:[< `complex64 ] as 'a Node.Type.t ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'b Node.t ->
  'b Node.t ->
  'a Node.t

val complexAbs : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?control_inputs:Node.p list ->
  [< `complex64 ] Node.t ->
  'a Node.t

val computeAccidentalHits : 
  ?name:string ->
  num_true:int ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  [ `int32 ] Node.t * [ `int64 ] Node.t * [ `float ] Node.t

val concat : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  't Node.t list ->
  't Node.t

val concatOffset : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t list ->
  [ `int32 ] Node.t list

val conj : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 ] as 'a Node.t ->
  'a Node.t

val controlTrigger : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `unit ] Node.t

val conv2D : 
  ?name:string ->
  strides:int list ->
  ?use_cudnn_on_gpu:bool ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val conv2DBackpropFilter : 
  ?name:string ->
  strides:int list ->
  ?use_cudnn_on_gpu:bool ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t ->
  'a Node.t

val conv2DBackpropInput : 
  ?name:string ->
  strides:int list ->
  ?use_cudnn_on_gpu:bool ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val conv3D : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val conv3DBackpropFilter : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val conv3DBackpropFilterV2 : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t ->
  'a Node.t

val conv3DBackpropInput : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val conv3DBackpropInputV2 : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val copy : 
  ?name:string ->
  ?tensor_name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val copyHost : 
  ?name:string ->
  ?tensor_name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val cos : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val countUpTo : 
  ?name:string ->
  limit:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val cropAndResize : 
  ?name:string ->
  ?method_:string ->
  ?extrapolation_value:float ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t

val cropAndResizeGradBoxes : 
  ?name:string ->
  ?method_:string ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t

val cropAndResizeGradImage : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?method_:string ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val cross : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val cumprod : 
  ?name:string ->
  ?exclusive:bool ->
  ?reverse:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val cumsum : 
  ?name:string ->
  ?exclusive:bool ->
  ?reverse:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val debugIdentity : 
  ?name:string ->
  ?tensor_name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val debugNanCount : 
  ?name:string ->
  ?tensor_name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int64 ] Node.t

val decodeJSONExample : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t

val decodePng : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  ?channels:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'dtype Node.t

val decodeGif : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  ?channels:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'dtype Node.t

val decodeRaw : 
  ?name:string ->
  type_:[< `double | `float | `int32 | `int64 ] as 'a Node.Type.t ->
  ?little_endian:bool ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'a Node.t

val deleteSessionTensor : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val depthToSpace : 
  ?name:string ->
  block_size:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val depthwiseConv2dNative : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val depthwiseConv2dNativeBackpropFilter : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t ->
  'a Node.t

val depthwiseConv2dNativeBackpropInput : 
  ?name:string ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val deserializeManySparse : 
  ?name:string ->
  type_1:'dtype Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t * 'dtype Node.t * [ `int64 ] Node.t

val destroyTemporaryVariable : 
  ?name:string ->
  var_name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val diag : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val diagPart : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val digamma : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val dilation2D : 
  ?name:string ->
  strides:int list ->
  rates:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val dilation2DBackpropFilter : 
  ?name:string ->
  strides:int list ->
  rates:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val dilation2DBackpropInput : 
  ?name:string ->
  strides:int list ->
  rates:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val div : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val drawBoundingBoxes : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'a Node.t ->
  [ `float ] Node.t ->
  'a Node.t

val dynamicPartition : 
  ?name:string ->
  num_partitions:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t list

val dynamicStitch : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t list ->
  't Node.t list ->
  't Node.t

val editDistance : 
  ?name:string ->
  ?normalize:bool ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `float ] Node.t

val elu : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val eluGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val encodePng : 
  ?name:string ->
  ?compression:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `string ] Node.t

val enter : 
  ?name:string ->
  frame_name:string ->
  ?is_constant:bool ->
  ?parallel_iterations:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val equal : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `bool | `complex64 | `double | `float | `int32 | `int64 | `string ] as 'a
    Node.t ->
  'a Node.t ->
  [ `bool ] Node.t

val erf : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val erfc : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val exit : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val exp : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val expandDims : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val extractGlimpse : 
  ?name:string ->
  ?centered:bool ->
  ?normalized:bool ->
  ?uniform_noise:bool ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t

val extractImagePatches : 
  ?name:string ->
  ksizes:int list ->
  strides:int list ->
  rates:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val fFT : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val fFT2D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val fFT3D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val fIFOQueue : 
  ?name:string ->
  component_types:Node.Type.p list ->
  ?shapes:Node.Dim.t list list ->
  ?capacity:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val fact : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val fill : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  't Node.t ->
  't Node.t

val fixedLengthRecordReader : 
  ?name:string ->
  ?header_bytes:int ->
  record_bytes:int ->
  ?footer_bytes:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val fixedUnigramCandidateSampler : 
  ?name:string ->
  num_true:int ->
  num_sampled:int ->
  unique:bool ->
  range_max:int ->
  ?vocab_file:string ->
  ?distortion:float ->
  ?num_reserved_ids:int ->
  ?num_shards:int ->
  ?shard:int ->
  ?unigrams:float list ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `float ] Node.t * [ `float ] Node.t

val floor : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val gather : 
  ?name:string ->
  ?validate_indices:bool ->
  ?control_inputs:Node.p list ->
  'tparams Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'tparams Node.t

val gatherNd : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  'tparams Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'tparams Node.t

val getSessionHandle : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `string ] Node.t

val getSessionTensor : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'dtype Node.t

val greater : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  [ `bool ] Node.t

val greaterEqual : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  [ `bool ] Node.t

val hSVToRGB : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val hashTable : 
  ?name:string ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val histogramSummary : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `string ] Node.t

val iFFT : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val iFFT2D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val iFFT3D : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `complex64 ] Node.t ->
  [ `complex64 ] Node.t

val identity : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val identityReader : 
  ?name:string ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val igamma : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val igammac : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val imag : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?control_inputs:Node.p list ->
  [< `complex64 ] Node.t ->
  'a Node.t

val imageSummary : 
  ?name:string ->
  ?max_images:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [< `float ] Node.t ->
  [ `string ] Node.t

val immutableConst : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  shape:Node.Dim.t list ->
  memory_region_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  'dtype Node.t

val inTopK : 
  ?name:string ->
  k:int ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [< `int32 | `int64 ] Node.t ->
  [ `bool ] Node.t

val initializeTable : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'tkey Node.t ->
  'tval Node.t ->
  [ `unit ] Node.t

val initializeTableFromTextFile : 
  ?name:string ->
  key_index:int ->
  value_index:int ->
  ?vocab_size:int ->
  ?delimiter:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val inv : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val invertPermutation : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t

val isFinite : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] Node.t ->
  [ `bool ] Node.t

val isInf : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] Node.t ->
  [ `bool ] Node.t

val isNan : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] Node.t ->
  [ `bool ] Node.t

val isVariableInitialized : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  'dtype Node.t ->
  [ `bool ] Node.t

val l2Loss : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val lRN : 
  ?name:string ->
  ?depth_radius:int ->
  ?bias:float ->
  ?alpha:float ->
  ?beta:float ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'a Node.t ->
  'a Node.t

val lRNGrad : 
  ?name:string ->
  ?depth_radius:int ->
  ?bias:float ->
  ?alpha:float ->
  ?beta:float ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val learnedUnigramCandidateSampler : 
  ?name:string ->
  num_true:int ->
  num_sampled:int ->
  unique:bool ->
  range_max:int ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `float ] Node.t * [ `float ] Node.t

val less : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  [ `bool ] Node.t

val lessEqual : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  [ `bool ] Node.t

val lgamma : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val linSpace : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val listDiff : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t ->
  't Node.t * [ `int32 ] Node.t

val log : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val logSoftmax : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val logUniformCandidateSampler : 
  ?name:string ->
  num_true:int ->
  num_sampled:int ->
  unique:bool ->
  range_max:int ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `float ] Node.t * [ `float ] Node.t

val logicalAnd : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `bool ] Node.t ->
  [ `bool ] Node.t

val logicalNot : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `bool ] Node.t

val logicalOr : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `bool ] Node.t ->
  [ `bool ] Node.t

val lookupTableExport : 
  ?name:string ->
  type_:'tkeys Node.Type.t ->
  type_1:'tvalues Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'tkeys Node.t * 'tvalues Node.t

val lookupTableFind : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'tin Node.t ->
  'tout Node.t ->
  'tout Node.t

val lookupTableImport : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'tin Node.t ->
  'tout Node.t ->
  [ `unit ] Node.t

val lookupTableInsert : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'tin Node.t ->
  'tout Node.t ->
  [ `unit ] Node.t

val lookupTableSize : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t

val loopCond : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `bool ] Node.t

val matMul : 
  ?name:string ->
  ?transpose_a:bool ->
  ?transpose_b:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val matchingFiles : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t

val matrixDeterminant : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val matrixInverse : 
  ?name:string ->
  ?adjoint:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val matrixSolve : 
  ?name:string ->
  ?adjoint:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val matrixSolveLs : 
  ?name:string ->
  ?fast:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  [ `double ] Node.t ->
  'a Node.t

val matrixTriangularSolve : 
  ?name:string ->
  ?lower:bool ->
  ?adjoint:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val max : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val maxPool : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'a Node.t ->
  'a Node.t

val maxPool3D : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val maxPool3DGrad : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val maxPoolGrad : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?data_format:string ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val maxPoolGradWithArgmax : 
  ?name:string ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val maxPoolWithArgmax : 
  ?name:string ->
  type_1:[< `int32 | `int64 ] as 'a Node.Type.t ->
  ksize:int list ->
  strides:int list ->
  padding:string ->
  ?control_inputs:Node.p list ->
  [< `float ] as 'b Node.t ->
  'b Node.t * 'a Node.t

val maximum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val mean : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val merge : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t list ->
  't Node.t * [ `int32 ] Node.t

val mergeSummary : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t list ->
  [ `string ] Node.t

val min : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val minimum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val mirrorPad : 
  ?name:string ->
  mode:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val mirrorPadGrad : 
  ?name:string ->
  mode:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val mod_ : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val mul : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val multinomial : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int64 ] Node.t

val mutableHashTable : 
  ?name:string ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val mutableHashTableOfTensors : 
  ?name:string ->
  ?container:string ->
  ?shared_name:string ->
  ?value_shape:Node.Dim.t list ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val neg : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val negTrain : 
  ?name:string ->
  vocab_count:int list ->
  num_negative_samples:int ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t ->
  [ `unit ] Node.t

val nextIteration : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val noOp : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `unit ] Node.t

val nonMaxSuppression : 
  ?name:string ->
  ?iou_threshold:float ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t

val notEqual : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `bool | `complex64 | `double | `float | `int32 | `int64 | `string ] as 'a
    Node.t ->
  'a Node.t ->
  [ `bool ] Node.t

val oneHot : 
  ?name:string ->
  ?axis:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  't Node.t ->
  't Node.t ->
  't Node.t

val pack : 
  ?name:string ->
  ?axis:int ->
  ?control_inputs:Node.p list ->
  't Node.t list ->
  't Node.t

val pad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val paddingFIFOQueue : 
  ?name:string ->
  component_types:Node.Type.p list ->
  ?shapes:Node.Dim.t list list ->
  ?capacity:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val parameterizedTruncatedNormal : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val parseTensor : 
  ?name:string ->
  type_:'out_type Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'out_type Node.t

val placeholderWithDefault : 
  ?name:string ->
  shape:Node.Dim.t list ->
  ?control_inputs:Node.p list ->
  'dtype Node.t ->
  'dtype Node.t

val polygamma : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val pow : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val priorityQueue : 
  ?name:string ->
  ?component_types:Node.Type.p list ->
  shapes:Node.Dim.t list list ->
  ?capacity:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val prod : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val quantizeAndDequantize : 
  ?name:string ->
  ?signed_input:bool ->
  ?num_bits:int ->
  ?range_given:bool ->
  ?input_min:float ->
  ?input_max:float ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val queueClose : 
  ?name:string ->
  ?cancel_pending_enqueues:bool ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val queueSize : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t

val rGBToHSV : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val randomCrop : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t

val randomGamma : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val randomShuffle : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val randomShuffleQueue : 
  ?name:string ->
  component_types:Node.Type.p list ->
  ?shapes:Node.Dim.t list list ->
  ?capacity:int ->
  ?min_after_dequeue:int ->
  ?seed:int ->
  ?seed2:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val randomStandardNormal : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val randomUniform : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val randomUniformInt : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  [< `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val rank : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t

val readFile : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t

val readerNumRecordsProduced : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t

val readerNumWorkUnitsCompleted : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t

val readerRead : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  [ `string ] Node.t * [ `string ] Node.t

val readerReadUpTo : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t ->
  [ `string ] Node.t * [ `string ] Node.t

val readerReset : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val readerRestoreState : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val readerSerializeState : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t

val real : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?control_inputs:Node.p list ->
  [< `complex64 ] Node.t ->
  'a Node.t

val reduceJoin : 
  ?name:string ->
  ?keep_dims:bool ->
  ?separator:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t ->
  [ `string ] Node.t

val refEnter : 
  ?name:string ->
  frame_name:string ->
  ?is_constant:bool ->
  ?parallel_iterations:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val refExit : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val refIdentity : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val refMerge : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t list ->
  't Node.t * [ `int32 ] Node.t

val refNextIteration : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val refSelect : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  't Node.t list ->
  't Node.t

val refSwitch : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `bool ] Node.t ->
  't Node.t * 't Node.t

val relu : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val relu6 : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val relu6Grad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val reluGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val reshape : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val resizeArea : 
  ?name:string ->
  ?align_corners:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t

val resizeBicubic : 
  ?name:string ->
  ?align_corners:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t

val resizeBilinear : 
  ?name:string ->
  ?align_corners:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t

val resizeBilinearGrad : 
  ?name:string ->
  ?align_corners:bool ->
  ?control_inputs:Node.p list ->
  [ `float ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val resizeNearestNeighbor : 
  ?name:string ->
  ?align_corners:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val resizeNearestNeighborGrad : 
  ?name:string ->
  ?align_corners:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val restore : 
  ?name:string ->
  type_:'dt Node.Type.t ->
  ?preferred_shard:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  'dt Node.t

val restoreSlice : 
  ?name:string ->
  type_:'dt Node.Type.t ->
  ?preferred_shard:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  'dt Node.t

val reverse : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `bool | `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `bool ] Node.t ->
  'a Node.t

val reverseSequence : 
  ?name:string ->
  seq_dim:int ->
  ?batch_dim:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int64 ] Node.t ->
  't Node.t

val rsqrt : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val sampleDistortedBoundingBox : 
  ?name:string ->
  ?seed:int ->
  ?seed2:int ->
  ?min_object_covered:float ->
  ?aspect_ratio_range:float list ->
  ?area_range:float list ->
  ?max_attempts:int ->
  ?use_image_if_no_bounding_boxes:bool ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] as 'a Node.t ->
  [ `float ] Node.t ->
  'a Node.t * 'a Node.t * [ `float ] Node.t

val scalarSummary : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `string ] Node.t

val scatterAdd : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t

val scatterSub : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t

val scatterUpdate : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [< `int32 | `int64 ] Node.t ->
  't Node.t ->
  't Node.t

val segmentMax : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val segmentMean : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val segmentMin : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val segmentProd : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val segmentSum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val select : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  't Node.t ->
  't Node.t ->
  't Node.t

val selfAdjointEig : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val selfAdjointEigV2 : 
  ?name:string ->
  ?compute_v:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t * 'a Node.t

val serializeManySparse : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `string ] Node.t

val serializeSparse : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `string ] Node.t

val shape : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t

val shapeN : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t list ->
  [ `int32 ] Node.t list

val shardedFilename : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `string ] Node.t

val shardedFilespec : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t ->
  [ `string ] Node.t

val sigmoid : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val sigmoidGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val sign : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val sin : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val size : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t

val skipgram : 
  ?name:string ->
  filename:string ->
  batch_size:int ->
  ?window_size:int ->
  ?min_count:int ->
  ?subsample:float ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t
  * [ `int32 ] Node.t
  * [ `int64 ] Node.t
  * [ `int32 ] Node.t
  * [ `int64 ] Node.t
  * [ `int32 ] Node.t
  * [ `int32 ] Node.t

val slice : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [< `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  't Node.t

val softmax : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t

val softmaxCrossEntropyWithLogits : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t * 'a Node.t

val softplus : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val softplusGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val softsign : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val softsignGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val spaceToBatch : 
  ?name:string ->
  block_size:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val spaceToDepth : 
  ?name:string ->
  block_size:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val sparseAdd : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t ->
  [ `int64 ] Node.t ->
  [< `double | `float | `int32 | `int64 ] Node.t ->
  [ `int64 ] Node.t * 'a Node.t * [ `int64 ] Node.t

val sparseAddGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t * 'a Node.t

val sparseApplyAdadelta : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val sparseApplyAdagrad : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val sparseApplyFtrl : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t

val sparseApplyMomentum : 
  ?name:string ->
  ?use_locking:bool ->
  ?use_nesterov:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t

val sparseApplyProximalAdagrad : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val sparseApplyProximalGradientDescent : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val sparseApplyRMSProp : 
  ?name:string ->
  ?use_locking:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val sparseConcat : 
  ?name:string ->
  concat_dim:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t list ->
  't Node.t list ->
  [ `int64 ] Node.t list ->
  [ `int64 ] Node.t * 't Node.t * [ `int64 ] Node.t

val sparseDenseCwiseAdd : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t

val sparseDenseCwiseDiv : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t

val sparseDenseCwiseMul : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t ->
  'a Node.t

val sparseMatMul : 
  ?name:string ->
  ?transpose_a:bool ->
  ?transpose_b:bool ->
  ?a_is_sparse:bool ->
  ?b_is_sparse:bool ->
  ?control_inputs:Node.p list ->
  [< `float ] Node.t ->
  [< `float ] Node.t ->
  [ `float ] Node.t

val sparseReduceSum : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val sparseReorder : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * 't Node.t

val sparseReshape : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `int64 ] Node.t

val sparseSegmentMean : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val sparseSegmentMeanGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val sparseSegmentSqrtN : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val sparseSegmentSqrtNGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val sparseSegmentSum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val sparseSoftmax : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `double | `float ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t

val sparseSoftmaxCrossEntropyWithLogits : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t * 'a Node.t

val sparseSparseMaximum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * 'a Node.t

val sparseSparseMinimum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t ->
  'a Node.t ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * 'a Node.t

val sparseTensorDenseAdd : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] as 'a Node.t ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'b Node.t ->
  'a Node.t ->
  'b Node.t ->
  'b Node.t

val sparseTensorDenseMatMul : 
  ?name:string ->
  ?adjoint_a:bool ->
  ?adjoint_b:bool ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  't Node.t ->
  't Node.t

val sparseToDense : 
  ?name:string ->
  ?validate_indices:bool ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  't Node.t ->
  't Node.t ->
  't Node.t

val split : 
  ?name:string ->
  num_split:int ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  't Node.t ->
  't Node.t list

val sqrt : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val square : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val squaredDifference : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val squeeze : 
  ?name:string ->
  ?squeeze_dims:int list ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val stack : 
  ?name:string ->
  ?stack_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val stackClose : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val stackPop : 
  ?name:string ->
  type_:'elem_type Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'elem_type Node.t

val stackPush : 
  ?name:string ->
  ?swap_memory:bool ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  't Node.t ->
  't Node.t

val stopGradient : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val stridedSlice : 
  ?name:string ->
  ?begin_mask:int ->
  ?end_mask:int ->
  ?ellipsis_mask:int ->
  ?new_axis_mask:int ->
  ?shrink_axis_mask:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [< `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  't Node.t

val stridedSliceGrad : 
  ?name:string ->
  ?begin_mask:int ->
  ?end_mask:int ->
  ?ellipsis_mask:int ->
  ?new_axis_mask:int ->
  ?shrink_axis_mask:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  'a Node.t ->
  't Node.t ->
  't Node.t

val stringJoin : 
  ?name:string ->
  ?separator:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t list ->
  [ `string ] Node.t

val stringSplit : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t * [ `string ] Node.t * [ `int64 ] Node.t

val stringToHashBucket : 
  ?name:string ->
  num_buckets:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t

val stringToHashBucketFast : 
  ?name:string ->
  num_buckets:int ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t

val stringToHashBucketStrong : 
  ?name:string ->
  num_buckets:int ->
  key:int list ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int64 ] Node.t

val stringToNumber : 
  ?name:string ->
  type_:[< `float | `int32 ] as 'a Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  'a Node.t

val sub : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val sum : 
  ?name:string ->
  ?keep_dims:bool ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val svd : 
  ?name:string ->
  ?compute_uv:bool ->
  ?full_matrices:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t * 'a Node.t * 'a Node.t

val switch : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `bool ] Node.t ->
  't Node.t * 't Node.t

val tFRecordReader : 
  ?name:string ->
  ?container:string ->
  ?shared_name:string ->
  ?compression_type:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val tan : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t

val tanh : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t

val tanhGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

val temporaryVariable : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  shape:Node.Dim.t list ->
  ?var_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  'dtype Node.t

val tensorArray : 
  ?name:string ->
  ?dynamic_size:bool ->
  ?clear_after_read:bool ->
  ?tensor_array_name:string ->
  ?control_inputs:Node.p list ->
  [ `int32 ] Node.t ->
  [ `string ] Node.t

val tensorArrayClose : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `unit ] Node.t

val tensorArrayConcat : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  ?element_shape_except0:Node.Dim.t list ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `float ] Node.t ->
  'dtype Node.t * [ `int64 ] Node.t

val tensorArrayGrad : 
  ?name:string ->
  source:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `float ] Node.t ->
  [ `string ] Node.t

val tensorArrayPack : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  ?element_shape:Node.Dim.t list ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `float ] Node.t ->
  'dtype Node.t

val tensorArrayRead : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t ->
  [ `float ] Node.t ->
  'dtype Node.t

val tensorArraySize : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `float ] Node.t ->
  [ `int32 ] Node.t

val tensorArraySplit : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  't Node.t ->
  [ `int64 ] Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t

val tensorArrayUnpack : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  't Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t

val tensorArrayWrite : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `string ] Node.t ->
  [ `int32 ] Node.t ->
  't Node.t ->
  [ `float ] Node.t ->
  [ `float ] Node.t

val tensorSummary : 
  ?name:string ->
  display_name:string ->
  ?description:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `string ] Node.t

val textLineReader : 
  ?name:string ->
  ?skip_header_lines:int ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val threadUnsafeUnigramCandidateSampler : 
  ?name:string ->
  num_true:int ->
  num_sampled:int ->
  unique:bool ->
  range_max:int ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `float ] Node.t * [ `float ] Node.t

val tile : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val tileGrad : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val topK : 
  ?name:string ->
  k:int ->
  ?sorted:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  'a Node.t * [ `int32 ] Node.t

val topKV2 : 
  ?name:string ->
  ?sorted:bool ->
  ?control_inputs:Node.p list ->
  [< `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t * [ `int32 ] Node.t

val transpose : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  [ `int32 ] Node.t ->
  't Node.t

val truncatedNormal : 
  ?name:string ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [< `int32 | `int64 ] Node.t ->
  'a Node.t

val uniformCandidateSampler : 
  ?name:string ->
  num_true:int ->
  num_sampled:int ->
  unique:bool ->
  range_max:int ->
  ?seed:int ->
  ?seed2:int ->
  ?control_inputs:Node.p list ->
  [ `int64 ] Node.t ->
  [ `int64 ] Node.t * [ `float ] Node.t * [ `float ] Node.t

val unique : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t * [ `int32 ] Node.t

val uniqueWithCounts : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t * [ `int32 ] Node.t * [ `int32 ] Node.t

val unpack : 
  ?name:string ->
  num:int ->
  ?axis:int ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t list

val unsortedSegmentSum : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `complex64 | `double | `float | `int32 | `int64 ] as 'a Node.t ->
  [< `int32 | `int64 ] Node.t ->
  [ `int32 ] Node.t ->
  'a Node.t

val variable : 
  ?name:string ->
  type_:'dtype Node.Type.t ->
  shape:Node.Dim.t list ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  'dtype Node.t

val where : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [ `bool ] Node.t ->
  [ `int64 ] Node.t

val wholeFileReader : 
  ?name:string ->
  ?container:string ->
  ?shared_name:string ->
  ?control_inputs:Node.p list ->
  unit ->
  [ `string ] Node.t

val zerosLike : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  't Node.t ->
  't Node.t

val zeta : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  [< `double | `float ] as 'a Node.t ->
  'a Node.t ->
  'a Node.t

module Placeholder : sig ... end

type 't b = ?name:string -> 't Node.t -> 't Node.t -> 't Node.t

val (-) : [< `complex64 | `double | `float | `int32 | `int64 ] b

val (/) : [< `complex64 | `double | `float | `int32 | `int64 ] b

val (*) : [< `complex64 | `double | `float | `int32 | `int64 ] b

val (*^) : [< `complex64 | `double | `float | `int32 ] b

val f_or_d : 
  ?shape:int list ->
  type_:[< `double | `float ] as 'b Node.Type.t ->
  float ->
  'b Node.t

val f : ?shape:int list -> float -> [ `float ] Node.t

val d : ?shape:int list -> float -> [ `double ] Node.t

val cf : ?shape:int list -> float list -> [ `float ] Node.t

val cd : ?shape:int list -> float list -> [ `double ] Node.t

val const_float : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  ?shape:int list ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  float list ->
  'a Node.t

val const_int : 
  ?name:string ->
  ?control_inputs:Node.p list ->
  ?shape:int list ->
  type_:[< `int32 | `int64 ] as 'a Node.Type.t ->
  int list ->
  'a Node.t

val const_string : 
  ?name:string ->
  ?shape:int list ->
  string list ->
  [ `string ] Node.t

val scalar : 
  ?empty_shape:unit ->
  type_:[< `double | `float ] as 'a Node.Type.t ->
  float ->
  'a Node.t

val four32 : [ `int32 ] Node.t

val three32 : [ `int32 ] Node.t

val two32 : [ `int32 ] Node.t

val one32 : [ `int32 ] Node.t

val zero32 : [ `int32 ] Node.t

type 'b reduce_fn = ?dims:int list -> 'b Node.t -> 'b Node.t constraint 'b = [< `complex64 | `double | `float | `int32 | `int64 ]

val reduce_sum : [< `complex64 | `double | `float | `int32 | `int64 ] reduce_fn

val reduce_min : [< `complex64 | `double | `float | `int32 | `int64 ] reduce_fn

val reduce_max : [< `complex64 | `double | `float | `int32 | `int64 ] reduce_fn

val reduce_mean : 
  [< `complex64 | `double | `float | `int32 | `int64 ] reduce_fn

val reduce_prod : 
  [< `complex64 | `double | `float | `int32 | `int64 ] reduce_fn

val reduce_all : ?dims:int list -> [ `bool ] Node.t -> [ `bool ] Node.t

val reduce_any : ?dims:int list -> [ `bool ] Node.t -> [ `bool ] Node.t

val save_ : 
  ?name:string ->
  [ `string ] Node.t ->
  [ `string ] Node.t ->
  Node.p list ->
  [ `unit ] Node.t

val save : filename:string -> (string * Node.p) list -> [ `unit ] Node.t

val split2 : 
  ?name:string ->
  [ `int32 ] Node.t ->
  't Node.t ->
  't Node.t * 't Node.t

val split3 : 
  ?name:string ->
  [ `int32 ] Node.t ->
  't Node.t ->
  't Node.t * 't Node.t * 't Node.t

val split4 : 
  ?name:string ->
  [ `int32 ] Node.t ->
  't Node.t ->
  't Node.t * 't Node.t * 't Node.t * 't Node.t

val range : [ `int32 ] Node.t -> [ `int32 ] Node.t

val placeholder : 
  ?name:string ->
  type_:'a Node.Type.t ->
  int list ->
  'a Placeholder.t

val dropout : 
  [< `double | `float ] as 'b Node.t ->
  keep_prob:'b Node.t ->
  'b Node.t

val cast : 
  ?name:string ->
  'srcT Node.t ->
  type_:'dstT Node.Type.t ->
  'dstT Node.t

val count : 'a Node.t -> dims:int list -> [ `int32 ] Node.t

type !'a moments = {

mean : 'a Node.t;
variance : 'a Node.t;

}

val moments : [< `double | `float ] as 'b Node.t -> dims:int list -> 'b moments

val normalize : 
  ?epsilon:float ->
  [< `double | `float ] as 'b Node.t ->
  'b moments ->
  'b Node.t

val cond_with_control_inputs : 
  [ `bool ] Node.t ->
  if_true:(control_inputs:Node.p list -> 'a Node.t) ->
  if_false:(control_inputs:Node.p list -> 'a Node.t) ->
  'a Node.t

val cond : 
  [ `bool ] Node.t ->
  if_true:'a Node.t ->
  if_false:'a Node.t ->
  'a Node.t

package tensorflow