quick TensorFlowSharp wrapper for F#

tensorflowwrap.fsx

#load @"E:\profile\fsi\.\packagegrp\CE8A46E8AAAB2DAD2A75F9585A0E8F0563C98AEA859A445DC4BF25F4B0C33943\.paket\load\main.group.fsx"

open System
open System.IO
open TensorFlow

Environment.SetEnvironmentVariable("Path", 
    Environment.GetEnvironmentVariable("Path") + ";" + @"E:\profile\fsi\packagegrp\CE8A46E8AAAB2DAD2A75F9585A0E8F0563C98AEA859A445DC4BF25F4B0C33943\packages\TensorFlowSharp\runtimes\win7-x64\native")



type TF(g : TFGraph, y : TFOutput) = 
    member x.TFGraph = g
    member x.TFOutput = y
    static member Abs(x : TF) = TF(x.TFGraph, x.TFGraph.Abs(x.TFOutput))
    static member Acos(x : TF) = TF(x.TFGraph, x.TFGraph.Acos(x.TFOutput))
    static member Asin(x : TF) = TF(x.TFGraph, x.TFGraph.Asin(x.TFOutput))
    static member Atan(x : TF) = TF(x.TFGraph, x.TFGraph.Atan(x.TFOutput))
    static member Atan2(x : TF, y : TF) = TF(x.TFGraph, x.TFGraph.Atan2(x.TFOutput, y.TFOutput))
    static member Ceiling(x : TF) = TF(x.TFGraph, x.TFGraph.Ceil(x.TFOutput))
    static member Exp(x : TF) = TF(x.TFGraph, x.TFGraph.Exp(x.TFOutput))
    static member Floor(x : TF) = TF(x.TFGraph, x.TFGraph.Floor(x.TFOutput))
    //static member Truncate(x : TF) = TF(x.TFGraph, x.TFGraph.Truncate(x.TFOutput))
    static member Round(x : TF) = TF(x.TFGraph, x.TFGraph.Round(x.TFOutput))
    static member Log(x : TF) = TF(x.TFGraph, x.TFGraph.Log(x.TFOutput))
    //static member Log10(x : TF) = TF(x.TFGraph, x.TFGraph.Log10(x.TFOutput))
    static member Sqrt(x : TF) = TF(x.TFGraph, x.TFGraph.Sqrt(x.TFOutput))
    static member Cos(x : TF) = TF(x.TFGraph, x.TFGraph.Cos(x.TFOutput))
    static member Cosh(x : TF) = TF(x.TFGraph, x.TFGraph.Cosh(x.TFOutput))
    static member Sin(x : TF) = TF(x.TFGraph, x.TFGraph.Sin(x.TFOutput))
    static member Sinh(x : TF) = TF(x.TFGraph, x.TFGraph.Sinh(x.TFOutput))
    static member Tan(x : TF) = TF(x.TFGraph, x.TFGraph.Tan(x.TFOutput))
    static member Tanh(x : TF) = TF(x.TFGraph, x.TFGraph.Tanh(x.TFOutput))
    static member Pow(x : TF, y : TF) = TF(x.TFGraph, x.TFGraph.Pow(x.TFOutput, y.TFOutput))
    static member (~-)(a : TF) = TF(a.TFGraph, a.TFGraph.Neg(a.TFOutput))
    static member (&&&)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.BitwiseAnd(a.TFOutput, b.TFOutput))
    static member (|||)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.BitwiseOr(a.TFOutput, b.TFOutput))
    static member (^^^)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.BitwiseXor(a.TFOutput, b.TFOutput))
    static member (+)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Add(a.TFOutput, b.TFOutput))
    static member ( * )(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.MatMul(a.TFOutput, b.TFOutput))
    static member (.*)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Mul(a.TFOutput, b.TFOutput))
    static member (/)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Div(a.TFOutput, b.TFOutput))
    static member (-)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Sub(a.TFOutput, b.TFOutput))
    static member (%)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Mod(a.TFOutput, b.TFOutput))
    static member (.=)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Equal(a.TFOutput, b.TFOutput))
    static member (.>=)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.GreaterEqual(a.TFOutput, b.TFOutput))
    static member (.<=)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.LessEqual(a.TFOutput, b.TFOutput))
    static member (.>)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Greater(a.TFOutput, b.TFOutput))
    static member (.<)(a : TF, b : TF) = TF(a.TFGraph, a.TFGraph.Less(a.TFOutput, b.TFOutput))

[<AutoOpen>]
module Ops = 
    let log1p (x : TF) = TF(x.TFGraph, x.TFGraph.Log1p(x.TFOutput))




type TFG(graph : TFGraph) = 
    member x.TFGraph = graph
    member this.Where(condition : TF, x : TF option, y : TF option, ?name : String) =
        let name = defaultArg name null
        TF(this.TFGraph, this.TFGraph.Where(condition.TFOutput, x |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, y |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, name))
    /// <summary>
    ///             Adds new dependencies for new tensors and operations created while the context is active.
    ///             </summary>
    member this.WithDependencies(dependencies : TFOperation[]) =
        this.TFGraph.WithDependencies(dependencies)
    /// <summary>
    ///             Imports a graph serialized into the graph
    ///             </summary><param name="graphDef">Serialized graph definition (in protocol buffer format).</param><param name="options">Import options.</param><param name="returnOutputs">Array large enough to contain all the return options.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param><remarks>
    ///               If you are tryig to load a file stored using the SavedModel file format, you should use the <see cref="T:TensorFlow.TFSession.FromSavedModel" /> API instead.
    ///             </remarks>
    member this.ImportGraphDef(graphDef : TFBuffer, options : TFImportGraphDefOptions, returnOutputs : TF[], ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.ImportGraphDef(graphDef, options, returnOutputs |> Array.map (fun x -> x.TFOutput), status)
    /// <summary>
    ///             Constructs a while loop with the specified inputs and a callback that composes the while loop
    ///             </summary><param name="inputs">Inputs.</param><param name="constructor">Callback method that fills out the various while loop parameters.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param><returns>
    ///             An array of TFOutputs from creating the While loop, or null if there is an error creating the 
    ///             while loop, or if the constructor raised an exception when it was invoked.
    ///             </returns>
    member this.While(inputs : TF[], constructor : TFGraph.WhileConstructor, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.While(inputs |> Array.map (fun x -> x.TFOutput), constructor, status) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///             Adds a gradient: the operations needed to compute the partial derivatives of sum of <paramref name="y" />` wrt to <paramref name="x" />.
    ///             </summary><returns>The partial derivatives, the size of the array is the same as the length of the <paramref name="y" /> array.</returns><param name="y">The y elements.</param><param name="x">The x elements.</param><param name="dx">Initial gradients, which represent the symbolic partial derivatives of some loss function `L` w.r.t. <paramref name="y" /> ).   
    ///             If the parameter is null, the implementation will use dx for 'OnesLike' for all shapes in <paramref name="y" /></param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param><remarks>
    ///             d(y[0] + y[1]+ ...)/dx[0], d(y[0] + y[1] + ...)/dx[1]z...
    ///             </remarks>
    member this.AddGradients(y : TF[], x : TF[], ?dx : TF[], ?status : TFStatus) =
        let dx = defaultArg dx null
        let status = defaultArg status null
        this.TFGraph.AddGradients(y |> Array.map (fun x -> x.TFOutput), x |> Array.map (fun x -> x.TFOutput), dx |> Array.map (fun x -> x.TFOutput), status) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///             Adds a gradient: the operations needed to compute the partial derivatives of sum of <paramref name="y" />` wrt to <paramref name="x" />.
    ///             </summary><returns>The partial derivatives, the size of the array is the same as the length of the <paramref name="y" /> array.</returns><param name="y">The y elements.</param><param name="x">The x elements.</param><param name="dx">Initial gradients, which represent the symbolic partial derivatives of some loss function `L` w.r.t. <paramref name="y" /> ).   
    ///             If the parameter is null, the implementation will use dx for 'OnesLike' for all shapes in <paramref name="y" /></param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param><remarks>
    ///             d(y[0] + y[1]+ ...)/dx[0], d(y[0] + y[1] + ...)/dx[1]z...
    ///             </remarks>
    member this.AddGradients(prefix : String, y : TF[], x : TF[], ?dx : TF[], ?status : TFStatus) =
        let dx = defaultArg dx null
        let status = defaultArg status null
        this.TFGraph.AddGradients(prefix, y |> Array.map (fun x -> x.TFOutput), x |> Array.map (fun x -> x.TFOutput), dx |> Array.map (fun x -> x.TFOutput), status) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///             Creates a TFFunction from a TFGraph
    ///             </summary><returns>The function.</returns><param name="functionName">Name of the new function.  Should match the operation name (OpDef.name) regexp [A-Z][A-Za-z0-9_.\\-/]*.  If appendHashToFunctioName is false, the name must be unique (at least those registered in graphs where this function will be used).</param><param name="description">Optional, human readable description of this function.</param><param name="operations">Array of operations to become the body of the function or null.  
    ///                 If no array is given , all the
    ///                 operations in function body will become part of the function
    ///                 except operations referenced in inputs. These operations
    ///                 must have a single output (these operations are typically
    ///                 placeholders created for the sole purpose of representing
    ///                 an input).
    ///             
    ///                 If an array is given, all operations
    ///                 in it will become part of the function. In particular, no
    ///                 automatic skipping of dummy input operations is performed.
    ///             </param><param name="inputs">Array that specify the inputs to the function, or null.  The names used for function inputs are normalized
    ///                 names of the operations (usually placeholders) pointed to by
    ///                 inputs.  These operation names should start with a letter.
    ///                 Normalization will convert all letters to lowercase and
    ///                 non-alphanumeric characters to '_' to make resulting names match
    ///                 the "[a-z][a-z0-9_]*" pattern for operation argument names.
    ///                 `inputs` cannot contain the same tensor twice.</param><param name="outputs">rray that specify the inputs to the function, or null.   This can contain the same tensor twice.</param><param name="outputNames">The names of the function's outputs.   The array either has the same elements of outputs, or be null.   Names must match "[a-z][a-z0-9_]*" regexp, if null is passed, the names are generated automatically.</param><param name="appendHashToFunctionName">If set to <c>true</c> appends hash to functionName, otherwise it will use the specified name in functionName.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param><remarks><para>
    ///               This method converts the graph whose operations (or a subset of its operations) will be converted
    ///               into a TFFunction.
    ///             </para><para>
    ///               Note that when the same TF_Output is listed as both an input and an output,
    ///               the corresponding function's output will equal to this input,
    ///               instead of the original node's output.
    ///             </para><para>
    ///             Callers must also satisfy the following constraints:
    ///             </para><para><paramref name="inputs" /> cannot refer to TFOutputs within a control flow context. For
    ///               example, one cannot use the output of "switch" node as input.
    ///             </para><para><paramref name="inputs" /> and <paramref name="outputs" /> cannot have reference types. Reference types are
    ///               not exposed through C API and are being replaced with Resources. We support
    ///               reference types inside function's body to support legacy code. Do not
    ///               use them in new code.
    ///             </para><para>
    ///               Every node in the function's body must have all of its inputs (including
    ///               control inputs). In other words, for every node in the body, each input
    ///               must be either listed in <paramref name="inputs" /> or must come from another node in
    ///               the body. In particular, it is an error to have a control edge going from
    ///               a node outside of the body into a node in the body. This applies to control
    ///               edges going from nodes referenced in <paramref name="inputs" /> to nodes in the body when
    ///               the former nodes are not in the body (automatically skipped or not
    ///               included in explicitly specified body).
    ///             </para></remarks>
    member this.ToFunction(functionName : String, description : String, operations : TFOperation[], inputs : TF[], outputs : TF[], outputNames : String[], ?appendHashToFunctionName : Boolean, ?status : TFStatus) =
        let appendHashToFunctionName = defaultArg appendHashToFunctionName false
        let status = defaultArg status null
        this.TFGraph.ToFunction(functionName, description, operations, inputs |> Array.map (fun x -> x.TFOutput), outputs |> Array.map (fun x -> x.TFOutput), outputNames, appendHashToFunctionName, status)
    /// <summary>
    ///             Returns the serialized VersionDef proto for this graph.
    ///             </summary><returns>The versions.</returns><param name="outputVersionDef">The buffer where the serialized protocol buffer will be stored.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.Versions(outputVersionDef : TFBuffer, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.Versions(outputVersionDef, status)
    member this.get_NumFunctions() =
        this.TFGraph.get_NumFunctions()
    member this.get_Functions() =
        this.TFGraph.get_Functions()
    member this.get_DeviceName() =
        this.TFGraph.get_DeviceName()
    /// <summary>
    ///             Attempts to evaluate the <paramref name="output" />.   This is only possible if <paramref name="output" /> does not
    ///             depend on any graph inputs - the function is safe to call if this is not the case though.
    ///             </summary><returns><c>true</c>, if the evaluation is successful, in which case the result is returned in <paramref name="tensor" />, <c>false</c> otherwise.</returns><param name="output">Output.</param><param name="tensor">Tensor.</param>
    member this.TryEvaluateConstant(output : TF, tensor : TFTensor byref) =
        this.TFGraph.TryEvaluateConstant(output.TFOutput, &tensor)
    member this.ToString() =
        this.TFGraph.ToString()
    /// <summary>
    ///               Gradient of Unbatch.
    ///             </summary><param name="original_input"></param><param name="batch_index"></param><param name="grad"></param><param name="id"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnbatchGrad'.
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Acts like Batch but using the given batch_index index of batching things as they
    ///               become available. This ensures that the gradients are propagated back in the
    ///               same session which did the forward pass.
    ///               
    ///               original_input: The input to the Unbatch operation this is the gradient of.
    ///               batch_index: The batch_index given to the Unbatch operation this is the gradient
    ///               of.
    ///               grad: The downstream gradient.
    ///               id: The id scalar emitted by Batch.
    ///               batched_grad: The return value, either an empty tensor or the batched gradient.
    ///               container: Container to control resource sharing.
    ///               shared_name: Instances of UnbatchGrad with the same container and shared_name
    ///               are assumed to possibly belong to the same batch. If left empty, the op name
    ///               will be used as the shared name.
    ///             </remarks>
    member this.UnbatchGrad(original_input : TF, batch_index : TF, grad : TF, id : TF, ?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnbatchGrad(original_input.TFOutput, batch_index.TFOutput, grad.TFOutput, id.TFOutput, container, shared_name, operName))
    /// <summary>
    ///               Determine the script codes of a given tensor of Unicode integer code points.
    ///             </summary><param name="input">
    ///               A Tensor of int32 Unicode code points.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnicodeScript'.
    ///             </param><returns>
    ///               A Tensor of int32 script codes corresponding to each input code point.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation converts Unicode code points to script codes corresponding to
    ///               each code point. Script codes correspond to International Components for
    ///               Unicode (ICU) UScriptCode values. See http://icu-project.org/apiref/icu4c/uscript_8h.html.
    ///               Returns -1 (USCRIPT_INVALID_CODE) for invalid codepoints. Output shape will
    ///               match input shape.
    ///             </remarks>
    member this.UnicodeScript(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnicodeScript(input.TFOutput, operName))
    /// <summary>
    ///               Generates labels for candidate sampling with a uniform distribution.
    ///             </summary><param name="true_classes">
    ///               A batch_size * num_true matrix, in which each row contains the
    ///               IDs of the num_true target_classes in the corresponding original label.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UniformCandidateSampler'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either seed or seed2 are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               An second seed to avoid seed collision.
    ///             </param><param name="num_true">
    ///               Number of true labels per context.
    ///             </param><param name="num_sampled">
    ///               Number of candidates to randomly sample.
    ///             </param><param name="unique">
    ///               If unique is true, we sample with rejection, so that all sampled
    ///               candidates in a batch are unique. This requires some approximation to
    ///               estimate the post-rejection sampling probabilities.
    ///             </param><param name="range_max">
    ///               The sampler will sample integers from the interval [0, range_max).
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               sampled_candidates: A vector of length num_sampled, in which each element is
    ///               the ID of a sampled candidate.
    ///               true_expected_count: A batch_size * num_true matrix, representing
    ///               the number of times each candidate is expected to occur in a batch
    ///               of sampled candidates. If unique=true, then this is a probability.
    ///               sampled_expected_count: A vector of length num_sampled, for each sampled
    ///               candidate representing the number of times the candidate is expected
    ///               to occur in a batch of sampled candidates.  If unique=true, then this is a
    ///               probability.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               See explanations of candidate sampling and the data formats at
    ///               go/candidate-sampling.
    ///               
    ///               For each batch, this op picks a single set of sampled candidate labels.
    ///               
    ///               The advantages of sampling candidates per-batch are simplicity and the
    ///               possibility of efficient dense matrix multiplication. The disadvantage is that
    ///               the sampled candidates must be chosen independently of the context and of the
    ///               true labels.
    ///             </remarks>
    member this.UniformCandidateSampler(true_classes : TF, num_true : Int64, num_sampled : Int64, unique : Boolean, range_max : Int64, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.UniformCandidateSampler(true_classes.TFOutput, num_true, num_sampled, unique, range_max, seed, seed2, operName)
    /// <summary>
    ///               Finds unique elements in a 1-D tensor.
    ///             </summary><param name="x">
    ///               1-D.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Unique'.
    ///             </param><param name="out_idx">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               y: 1-D.
    ///               idx: 1-D.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This operation returns a tensor <c>y</c> containing all of the unique elements of <c>x</c>
    ///               sorted in the same order that they occur in <c>x</c>. This operation also returns a
    ///               tensor <c>idx</c> the same size as <c>x</c> that contains the index of each value of <c>x</c>
    ///               in the unique output <c>y</c>. In other words:
    ///               
    ///               <c>y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]</c>
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
    ///               y, idx = unique(x)
    ///               y ==&amp;gt; [1, 2, 4, 7, 8]
    ///               idx ==&amp;gt; [0, 0, 1, 2, 2, 2, 3, 4, 4]
    ///                </code></remarks>
    member this.Unique(x : TF, ?out_idx : TFDataType, ?operName : String) =
        let out_idx = defaultArg (out_idx |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.Unique(x.TFOutput, out_idx, operName)
    member this.UniqueV2(x : TF, axis : TF, ?out_idx : TFDataType, ?operName : String) =
        let out_idx = defaultArg (out_idx |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.UniqueV2(x.TFOutput, axis.TFOutput, out_idx, operName)
    /// <summary>
    ///               Finds unique elements in a 1-D tensor.
    ///             </summary><param name="x">
    ///               1-D.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UniqueWithCounts'.
    ///             </param><param name="out_idx">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               y: 1-D.
    ///               idx: 1-D.
    ///               count: 1-D.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This operation returns a tensor <c>y</c> containing all of the unique elements of <c>x</c>
    ///               sorted in the same order that they occur in <c>x</c>. This operation also returns a
    ///               tensor <c>idx</c> the same size as <c>x</c> that contains the index of each value of <c>x</c>
    ///               in the unique output <c>y</c>. Finally, it returns a third tensor <c>count</c> that
    ///               contains the count of each element of <c>y</c> in <c>x</c>. In other words:
    ///               
    ///               <c>y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]</c>
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
    ///               y, idx, count = unique_with_counts(x)
    ///               y ==&amp;gt; [1, 2, 4, 7, 8]
    ///               idx ==&amp;gt; [0, 0, 1, 2, 2, 2, 3, 4, 4]
    ///               count ==&amp;gt; [2, 1, 3, 1, 2]
    ///                </code></remarks>
    member this.UniqueWithCounts(x : TF, ?out_idx : TFDataType, ?operName : String) =
        let out_idx = defaultArg (out_idx |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.UniqueWithCounts(x.TFOutput, out_idx, operName)
    member this.UniqueWithCountsV2(x : TF, axis : TF, ?out_idx : TFDataType, ?operName : String) =
        let out_idx = defaultArg (out_idx |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.UniqueWithCountsV2(x.TFOutput, axis.TFOutput, out_idx, operName)
    /// <summary>
    ///               Unpacks a given dimension of a rank-<c>R</c> tensor into <c>num</c> rank-<c>(R-1)</c> tensors.
    ///             </summary><param name="value">
    ///               1-D or higher, with <c>axis</c> dimension size equal to <c>num</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Unpack'.
    ///             </param><param name="axis">
    ///               Optional argument
    ///               Dimension along which to unpack.  Negative values wrap around, so the
    ///               valid range is <c>[-R, R)</c>.
    ///             </param><param name="num"></param><returns>
    ///               The list of tensors unpacked from <c>value</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Unpacks <c>num</c> tensors from <c>value</c> by chipping it along the <c>axis</c> dimension.
    ///               For example, given a tensor of shape <c>(A, B, C, D)</c>;
    ///               
    ///               If <c>axis == 0</c> then the i'th tensor in <c>output</c> is the slice <c>value[i, :, :, :]</c>
    ///               and each tensor in <c>output</c> will have shape <c>(B, C, D)</c>. (Note that the
    ///               dimension unpacked along is gone, unlike <c>split</c>).
    ///               
    ///               If <c>axis == 1</c> then the i'th tensor in <c>output</c> is the slice <c>value[:, i, :, :]</c>
    ///               and each tensor in <c>output</c> will have shape <c>(A, C, D)</c>.
    ///               Etc.
    ///               
    ///               This is the opposite of <c>pack</c>.
    ///             </remarks>
    member this.Unpack(value : TF, num : Int64, ?axis : Int64, ?operName : String) =
        let axis = defaultArg (axis |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.Unpack(value.TFOutput, num, axis, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Converts a flat index or array of flat indices into a tuple of
    ///             </summary><param name="indices">
    ///               An 0-D or 1-D <c>int</c> Tensor whose elements are indices into the
    ///               flattened version of an array of dimensions dims.
    ///             </param><param name="dims">
    ///               An 1-D <c>int</c> Tensor. The shape of the array to use for unraveling
    ///               indices.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnravelIndex'.
    ///             </param><returns>
    ///               An 2-D (or 1-D if indices is 0-D) tensor where each row has the
    ///               same shape as the indices array.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               coordinate arrays.
    ///               
    ///               @compatibility(numpy)
    ///               Equivalent to np.unravel_index
    ///               @end_compatibility
    ///             </remarks>
    member this.UnravelIndex(indices : TF, dims : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnravelIndex(indices.TFOutput, dims.TFOutput, operName))
    /// <summary>
    ///               Computes the maximum along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A tensor whose shape is a prefix of <c>data.shape</c>.END
    ///               }
    ///               out_arg {
    ///               name: "output"
    ///               description: &amp;lt;&amp;lt;END
    ///               Has same shape as data, except for the first <c>segment_ids.rank</c>
    ///               dimensions, which are replaced with a single dimension which has size
    ///               <c>num_segments</c>.
    ///             </param><param name="num_segments"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnsortedSegmentMax'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               This operator is similar to the unsorted segment sum operator found
    ///               [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
    ///               Instead of computing the sum over segments, it computes the maximum such that:
    ///               
    ///               \\(output_i = \max_{j...} data[j...]\\) where max is over tuples <c>j...</c> such
    ///               that <c>segment_ids[j...] == i</c>.
    ///               
    ///               If the maximum is empty for a given segment ID <c>i</c>, it outputs the smallest
    ///               possible value for the specific numeric type,
    ///               <c>output[i] = numeric_limits&amp;lt;T&amp;gt;::lowest()</c>.
    ///               
    ///               If the given segment ID <c>i</c> is negative, then the corresponding value is
    ///               dropped, and will not be included in the result.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentMax.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.UnsortedSegmentMax(data : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnsortedSegmentMax(data.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Computes the minimum along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A tensor whose shape is a prefix of <c>data.shape</c>.
    ///             </param><param name="num_segments"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnsortedSegmentMin'.
    ///             </param><returns>
    ///               Has same shape as data, except for the first <c>segment_ids.rank</c>
    ///               dimensions, which are replaced with a single dimension which has size
    ///               <c>num_segments</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)
    ///               for an explanation of segments.
    ///               
    ///               This operator is similar to the unsorted segment sum operator found
    ///               [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
    ///               Instead of computing the sum over segments, it computes the minimum such that:
    ///               
    ///               \\(output_i = \min_{j...} data_[j...]\\) where min is over tuples <c>j...</c> such
    ///               that <c>segment_ids[j...] == i</c>.
    ///               
    ///               If the minimum is empty for a given segment ID <c>i</c>, it outputs the largest
    ///               possible value for the specific numeric type,
    ///               <c>output[i] = numeric_limits&amp;lt;T&amp;gt;::max()</c>.
    ///               
    ///               If the given segment ID <c>i</c> is negative, then the corresponding value is
    ///               dropped, and will not be included in the result.
    ///             </remarks>
    member this.UnsortedSegmentMin(data : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnsortedSegmentMin(data.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Computes the product along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A tensor whose shape is a prefix of <c>data.shape</c>.
    ///             </param><param name="num_segments"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnsortedSegmentProd'.
    ///             </param><returns>
    ///               Has same shape as data, except for the first <c>segment_ids.rank</c>
    ///               dimensions, which are replaced with a single dimension which has size
    ///               <c>num_segments</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)
    ///               for an explanation of segments.
    ///               
    ///               This operator is similar to the unsorted segment sum operator found
    ///               [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
    ///               Instead of computing the sum over segments, it computes the product of all
    ///               entries belonging to a segment such that:
    ///               
    ///               \\(output_i = \prod_{j...} data[j...]\\) where the product is over tuples
    ///               <c>j...</c> such that <c>segment_ids[j...] == i</c>.
    ///               
    ///               If there is no entry for a given segment ID <c>i</c>, it outputs 1.
    ///               
    ///               If the given segment ID <c>i</c> is negative, then the corresponding value is
    ///               dropped, and will not be included in the result.
    ///             </remarks>
    member this.UnsortedSegmentProd(data : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnsortedSegmentProd(data.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Computes the sum along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A tensor whose shape is a prefix of <c>data.shape</c>.
    ///             </param><param name="num_segments"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UnsortedSegmentSum'.
    ///             </param><returns>
    ///               Has same shape as data, except for the first <c>segment_ids.rank</c>
    ///               dimensions, which are replaced with a single dimension which has size
    ///               <c>num_segments</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Computes a tensor such that
    ///               \\(output[i] = \sum_{j...} data[j...]\\) where the sum is over tuples <c>j...</c> such
    ///               that <c>segment_ids[j...] == i</c>.  Unlike <c>SegmentSum</c>, <c>segment_ids</c>
    ///               need not be sorted and need not cover all values in the full
    ///               range of valid values.
    ///               
    ///               If the sum is empty for a given segment ID <c>i</c>, <c>output[i] = 0</c>.
    ///               If the given segment ID <c>i</c> is negative, the value is dropped and will not be
    ///               added to the sum of the segment.
    ///               
    ///               <c>num_segments</c> should equal the number of distinct segment IDs.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentSum.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.UnsortedSegmentSum(data : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UnsortedSegmentSum(data.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Op is similar to a lightweight Dequeue.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Unstage'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The basic functionality is similar to dequeue with many fewer
    ///               capabilities and options.  This Op is optimized for performance.
    ///             </remarks>
    member this.Unstage(dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.Unstage(dtypes, capacity, memory_limit, container, shared_name, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Applies upper_bound(sorted_search_values, values) along each row.
    ///             </summary><param name="sorted_inputs">
    ///               2-D Tensor where each row is ordered.
    ///             </param><param name="values">
    ///               2-D Tensor with the same numbers of rows as <c>sorted_search_values</c>. Contains
    ///               the values that will be searched for in <c>sorted_search_values</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'UpperBound'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               A <c>Tensor</c> with the same shape as <c>values</c>.  It contains the last scalar index
    ///               into the last dimension where values can be inserted without changing the
    ///               ordered property.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Each set of rows with the same index in (sorted_inputs, values) is treated
    ///               independently.  The resulting row is the equivalent of calling
    ///               <c>np.searchsorted(sorted_inputs, values, side='right')</c>.
    ///               
    ///               The result is not a global index to the entire
    ///               <c>Tensor</c>, but rather just the index in the last dimension.
    ///               
    ///               A 2-D example:
    ///               sorted_sequence = [[0, 3, 9, 9, 10],
    ///               [1, 2, 3, 4, 5]]
    ///               values = [[2, 4, 9],
    ///               [0, 2, 6]]
    ///               
    ///               result = UpperBound(sorted_sequence, values)
    ///               
    ///               result == [[1, 2, 4],
    ///               [0, 2, 5]]
    ///             </remarks>
    member this.UpperBound(sorted_inputs : TF, values : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.UpperBound(sorted_inputs.TFOutput, values.TFOutput, out_type, operName))
    /// <summary>
    ///               Creates a handle to a Variable resource.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'VarHandleOp'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               the container this variable is placed in.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               the name by which this variable is referred to.
    ///             </param><param name="dtype">
    ///               the type of this variable. Must agree with the dtypes
    ///               of all ops using this variable.
    ///             </param><param name="shape">
    ///               The (possibly partially specified) shape of this variable.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.VarHandleOp(dtype : TFDataType, shape : TFShape, ?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.VarHandleOp(dtype, shape, container, shared_name, operName))
    /// <summary>
    ///               Use VariableV2 instead.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Variable'.
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="shape"></param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Variable(shape : TFShape, dtype : TFDataType, ?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Variable(shape, dtype, container, shared_name, operName))
    /// <summary>
    ///               Returns the shape of the variable pointed to by <c>resource</c>.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'VariableShape'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns a 1-D integer tensor representing the shape of <c>input</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
    ///               shape(t) ==&amp;gt; [2, 2, 3]
    ///                </code></remarks>
    member this.VariableShape(input : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.VariableShape(input.TFOutput, out_type, operName))
    /// <summary>
    ///               Holds state in the form of a tensor that persists across steps.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'VariableV2'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this variable is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this variable is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><param name="shape">
    ///               The shape of the variable tensor.
    ///             </param><param name="dtype">
    ///               The type of elements in the variable tensor.
    ///             </param><returns>
    ///               A reference to the variable tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Outputs a ref to the tensor state so it may be read or modified.
    ///               TODO(zhifengc/mrry): Adds a pointer to a more detail document
    ///               about sharing states in tensorflow.
    ///             </remarks>
    member this.VariableV2(shape : TFShape, dtype : TFDataType, ?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.VariableV2(shape, dtype, container, shared_name, operName))
    /// <summary>
    ///               Checks whether a resource handle-based variable has been initialized.
    ///             </summary><param name="resource">
    ///               the input resource handle.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'VarIsInitializedOp'.
    ///             </param><returns>
    ///               a scalar boolean which is true if the variable has been
    ///               initialized.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.VarIsInitializedOp(resource : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.VarIsInitializedOp(resource.TFOutput, operName))
    /// <summary>
    ///               A Reader that outputs the entire contents of a file as a value.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'WholeFileReader'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this reader is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this reader is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><returns>
    ///               The handle to reference the Reader.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               To use, enqueue filenames in a Queue.  The output of ReaderRead will
    ///               be a filename (key) and the contents of that file (value).
    ///             </remarks>
    member this.WholeFileReader(?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.WholeFileReader(container, shared_name, operName))
    /// <summary>
    ///               A Reader that outputs the entire contents of a file as a value.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'WholeFileReaderV2'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this reader is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this reader is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><returns>
    ///               The handle to reference the Reader.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               To use, enqueue filenames in a Queue.  The output of ReaderRead will
    ///               be a filename (key) and the contents of that file (value).
    ///             </remarks>
    member this.WholeFileReaderV2(?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.WholeFileReaderV2(container, shared_name, operName))
    /// <summary>
    ///               A dataset that creates window datasets from the input dataset.
    ///             </summary><param name="input_dataset"></param><param name="size">
    ///               A scalar representing the number of elements to accumulate in a window.
    ///             </param><param name="shift">
    ///               A scalar representing the steps moving the sliding window forward in one
    ///               iteration. It must be positive.
    ///             </param><param name="stride">
    ///               A scalar representing the stride of the input elements of the sliding window.
    ///               It must be positive.
    ///             </param><param name="drop_remainder">
    ///               A scalar representing whether a window should be dropped in case its size is
    ///               smaller than desired.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'WindowDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.WindowDataset(input_dataset : TF, size : TF, shift : TF, stride : TF, drop_remainder : TF, output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.WindowDataset(input_dataset.TFOutput, size.TFOutput, shift.TFOutput, stride.TFOutput, drop_remainder.TFOutput, output_types, output_shapes, operName))
    /// <summary>
    ///               Worker heartbeat op.
    ///             </summary><param name="request">
    ///               A string tensor containing a serialized WorkerHeartbeatRequest
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'WorkerHeartbeat'.
    ///             </param><returns>
    ///               A string tensor containing a serialized WorkerHeartbeatResponse
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Heartbeats may be sent periodically to indicate the coordinator is still active,
    ///               to retrieve the current worker status and to expedite shutdown when necessary.
    ///             </remarks>
    member this.WorkerHeartbeat(request : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.WorkerHeartbeat(request.TFOutput, operName))
    /// <summary>
    ///               Writes contents to the file at input filename. Creates file and recursively
    ///             </summary><param name="filename">
    ///               scalar. The name of the file to which we write the contents.
    ///             </param><param name="contents">
    ///               scalar. The content to be written to the output file.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'WriteFile'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               creates directory if not existing.
    ///             </remarks>
    member this.WriteFile(filename : TF, contents : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.WriteFile(filename.TFOutput, contents.TFOutput, operName)
    /// <summary>
    ///               Returns 0 if x == 0, and x / y otherwise, elementwise.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Xdivy'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Xdivy(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Xdivy(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Xlogy'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Xlogy(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Xlogy(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Returns a tensor of zeros with the same shape and type as x.
    ///             </summary><param name="x">
    ///               a tensor of type T.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ZerosLike'.
    ///             </param><returns>
    ///               a tensor of the same shape and type as x but filled with zeros.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ZerosLike(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ZerosLike(x.TFOutput, operName))
    /// <summary>
    ///               Compute the Hurwitz zeta function \\(\zeta(x, q)\\).
    ///             </summary><param name="x"></param><param name="q"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Zeta'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The Hurwitz zeta function is defined as:
    ///               
    ///               
    ///               \\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
    ///             </remarks>
    member this.Zeta(x : TF, q : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Zeta(x.TFOutput, q.TFOutput, operName))
    /// <summary>
    ///               Creates a dataset that zips together <c>input_datasets</c>.
    ///             </summary><param name="input_datasets"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ZipDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ZipDataset(input_datasets : TF[], output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ZipDataset(input_datasets |> Array.map (fun x -> x.TFOutput), output_types, output_shapes, operName))
    /// <summary>
    ///               Returns a constant tensor.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Const'.
    ///             </param><param name="value">
    ///               Attr <c>value</c> is the tensor to return.
    ///             </param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Const(value : TFTensor, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Const(value, operName))
    /// <summary>
    ///             Computes the sum of elements across dimensions of a tensor.
    ///             </summary><returns>The reduced tensor.</returns><param name="input">The tensor to reduce. Should have numeric type.</param><param name="axis">The dimensions to reduce. If not se (the default), reduces all dimensions.</param><param name="keep_dims">If set to <c>true</c> retains reduced dimensions with length 1.</param><param name="operName">A name for the operation, optional.</param><remarks>
    ///               Reduces input_tensor along the dimensions given in axis.
    ///             Unless keep_dims is true, the rank of the tensor is reduced by 1 for each
    ///             entry in axis. If keep_dims is true, the reduced dimensions
    ///             are retained with length 1.
    ///             
    ///             If axis has no entries, all dimensions are reduced, and a
    ///             tensor with a single element is returned.
    ///             </remarks>
    member this.ReduceSum(input : TF, ?axis : TF, ?keep_dims : Nullable<Boolean>, ?operName : String) =
        let keep_dims = defaultArg keep_dims (Nullable(false))
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReduceSum(input.TFOutput, axis |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, keep_dims, operName))
    /// <summary>
    ///             Computes the product of elements across dimensions of a tensor.
    ///             </summary><returns>The reduced tensor.</returns><param name="input">The tensor to reduce. Should have numeric type.</param><param name="axis">The dimensions to reduce. If not se (the default), reduces all dimensions.</param><param name="keep_dims">If set to <c>true</c> retains reduced dimensions with length 1.</param><param name="operName">A name for the operation, optional.</param><remarks>
    ///               Reduces input_tensor along the dimensions given in axis.
    ///             Unless keep_dims is true, the rank of the tensor is reduced by 1 for each
    ///             entry in axis. If keep_dims is true, the reduced dimensions
    ///             are retained with length 1.
    ///             
    ///             If axis has no entries, all dimensions are reduced, and a
    ///             tensor with a single element is returned.
    ///             </remarks>
    member this.ReduceProd(input : TF, ?axis : TF, ?keep_dims : Nullable<Boolean>, ?operName : String) =
        let keep_dims = defaultArg keep_dims (Nullable(false))
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReduceProd(input.TFOutput, axis |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, keep_dims, operName))
    /// <summary>
    ///             Computes the mean of elements across dimensions of a tensor.
    ///             </summary><returns>The reduced tensor.</returns><param name="input">The tensor to reduce. Should have numeric type.</param><param name="axis">The dimensions to reduce. If not set (the default), reduces all dimensions.</param><param name="keep_dims">If set to <c>true</c> retains reduced dimensions with length 1.</param><param name="operName">A name for the operation, optional.</param><remarks><para>
    ///               Reduces input_tensor along the dimensions given in axis.
    ///             Unless keep_dims is true, the rank of the tensor is reduced by 1 for each
    ///             entry in axis. If keep_dims is true, the reduced dimensions
    ///             are retained with length 1.</para><para>
    ///             If axis has no entries, all dimensions are reduced, and a
    ///             tensor with a single element is returned.</para></remarks>
    member this.ReduceMean(input : TF, ?axis : TF, ?keep_dims : Nullable<Boolean>, ?operName : String) =
        let keep_dims = defaultArg keep_dims (Nullable(false))
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReduceMean(input.TFOutput, axis |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, keep_dims, operName))
    /// <summary>
    ///               Use VariableV2 instead.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Variable'.
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="shape"></param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Variable(initialValue : TF, init : TFOperation byref, value : TFOutput byref, ?trainable : Boolean, ?operName : String) =
        let trainable = defaultArg trainable true
        let operName = defaultArg operName null
        this.TFGraph.Variable(initialValue.TFOutput, &init, &value, trainable, operName)
    /// <summary>
    ///             Registers a specified variable as an initialization variable.
    ///             </summary><param name="variable">Variable to register.</param><remarks><para>
    ///             This is a convenience method to track the variables that need to be initialized in the graph,
    ///             you can retrieve the list of all those variables by calling the <see cref="M:TensorFlow.TFGraph.GetGlobalVariablesInitializer" />
    ///             which will return this list and clear the state at that point.
    ///             </para><para>
    ///             You typically use this method from helper methods to register all the variables that you want
    ///             initialized, and a higher level method will retrieve all these variables and initialize them
    ///             at their convenience.
    ///             </para></remarks>
    member this.AddInitVariable(variable : TFOperation) =
        this.TFGraph.AddInitVariable(variable)
    /// <summary>
    ///             Gets the list of all registered global variables.
    ///             </summary><returns>The array of variables that should be initialized.</returns><remarks>
    ///             After this method is invoked the list of pending initialization variables
    ///             is cleared.
    ///             </remarks>
    member this.GetGlobalVariablesInitializer() =
        this.TFGraph.GetGlobalVariablesInitializer()
    /// <summary>
    ///             Gets the list of all registered trainable variables.
    ///             </summary><returns>The array of variables that should be trained.</returns>
    member this.GetTrainableVariables() =
        this.TFGraph.GetTrainableVariables()
    /// <summary>
    ///               Use VariableV2 instead.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Variable'.
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="shape"></param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Variable(initialValue : TF, value : TFOutput byref, ?trainable : Boolean, ?operName : String) =
        let trainable = defaultArg trainable true
        let operName = defaultArg operName null
        this.TFGraph.Variable(initialValue.TFOutput, &value, trainable, operName)
    /// <summary>
    ///               Use VariableV2 instead.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Variable'.
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="shape"></param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Variable(initialValue : TF, ?trainable : Boolean, ?operName : String) =
        let trainable = defaultArg trainable true
        let operName = defaultArg operName null
        this.TFGraph.Variable(initialValue.TFOutput, trainable, operName)
    member this.get_Seed() =
        this.TFGraph.get_Seed()
    member this.set_Seed(value : Nullable<Int32>) =
        this.TFGraph.set_Seed(value)
    /// <summary>
    ///             Returns the graph and local seeds based on an optionally set incoming seed value.
    ///             </summary><param name="operationSeed">The seed value that might be set.</param><param name="graphSeed">Returned graph seed.</param><param name="localSeed">Returned local seed.</param><remarks>
    ///             This helper function returns two seeds derived from graph-level and op-level seeds.
    ///             Many random operations internally use the two seeds to allow user to change 
    ///             the seed globally for a graph, or for only specific operations.
    ///             </remarks>
    member this.GetRandomSeeds(operationSeed : Nullable<Int32>, graphSeed : Int32 byref, localSeed : Int32 byref) =
        this.TFGraph.GetRandomSeeds(operationSeed, &graphSeed, &localSeed)
    /// <summary>
    ///             Computes dropout. 
    ///             </summary><param name="x">A tensor.</param><param name="keep_prob">A scalar Tensor with the same type as x. The probability that each element is kept.</param><param name="noise_shape">A 1-D Tensor of type int32, representing the shape for randomly generated keep/drop flags.</param><param name="seed">Integer seed used for the random distribution, using the TensorFlow SetRandomSeed .</param><param name="operName">Operation name, optional.</param><remarks>
    ///             With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, 
    ///             otherwise outputs 0. The scaling is so that the expected sum is unchanged.
    ///             </remarks>
    member this.Dropout(x : TF, keep_prob : TF, ?noise_shape : TFShape, ?seed : Int32, ?operName : String) =
        let noise_shape = defaultArg noise_shape null
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Dropout(x.TFOutput, keep_prob.TFOutput, noise_shape, seed, operName))
    /// <summary>
    ///             Computes dropout. 
    ///             </summary><param name="x">A tensor.</param><param name="keep_prob">A scalar Tensor with the same type as x. The probability that each element is kept.</param><param name="noise_shape">A 1-D Tensor of type int32, representing the shape for randomly generated keep/drop flags.</param><param name="seed">Integer seed used for the random distribution, using the TensorFlow SetRandomSeed .</param><param name="operName">Operation name, optional.</param><remarks>
    ///             With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, 
    ///             otherwise outputs 0. The scaling is so that the expected sum is unchanged.
    ///             </remarks>
    member this.Dropout(x : TF, keep_prob : Double, ?noise_shape : TFShape, ?seed : Int32, ?operName : String) =
        let noise_shape = defaultArg noise_shape null
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Dropout(x.TFOutput, keep_prob, noise_shape, seed, operName))
    /// <summary>
    ///             Clips tensor values to a maximum L2-norm.
    ///             </summary><remarks><para>
    ///             Given a tensor <paramref name="x" />, and a maximum clip value <paramref name="clip_norm" />, this operation normalizes 
    ///             <paramref name="x" /> so that its L2-norm is less than or equal to <paramref name="clip_norm" />, along the dimensions 
    ///             given in <paramref name="axes" />. Specifically, in the default case where all dimensions are used for calculation, if
    ///             the L2-norm of <paramref name="x" /> is already less than or equal to <paramref name="clip_norm" />, then <paramref name="x" />
    ///             is not modified. If the L2-norm is greater than <paramref name="clip_norm" />, then this operation returns a tensor of 
    ///             the same type and shape as <paramref name="x" /> with its values set to: <c>t* clip_norm / l2norm(t)</c></para></remarks><param name="x">The tensor.</param><param name="clip_norm">The minimum value to clip by. A 0 - D(scalar) tensor, or a tensor with the same shape as <paramref name="x" />.</param><param name="axes">The minimum value to clip by. A 0 - D(scalar) tensor, or a tensor with the same shape as <paramref name="x" />.</param><param name="operName">Operation name, optional.</param><returns>A clipped <see cref="T:TensorFlow.TFOutput">tensor</see>.</returns>
    member this.ClipByNorm(x : TF, clip_norm : TF, ?axes : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ClipByNorm(x.TFOutput, clip_norm.TFOutput, axes |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, operName))
    /// <summary>
    ///             Computes the global norm of multiple tensors.
    ///             </summary><remarks><para>
    ///              Given a tuple or list of tensors <paramref name="tensors" />, this operation returns the global norm of the elements in all tensors 
    ///              in <paramref name="tensors" />. The global norm is computed as: <c>global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))</c>. Any 
    ///              entries in <paramref name="tensors" /> that are of type None are ignored.</para></remarks><param name="tensors">The input tensors.</param><param name="operName">Operation name, optional.</param><returns>A clipped <see cref="T:TensorFlow.TFOutput">tensor</see>.</returns>
    member this.GlobalNorm(tensors : TF[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.GlobalNorm(tensors |> Array.map (fun x -> x.TFOutput), operName))
    /// <summary>
    ///             Clips tensor values to a maximum average L2-norm.
    ///             </summary><remarks>
    ///             Given a tensor <paramref name="x" />, and a maximum clip value <paramref name="clip_norm" />, this operation 
    ///             normalizes <paramref name="x" /> so that its its average L2-norm is less than or equal to <paramref name="clip_norm" />.
    ///             Specifically, if the average L2-norm is already less than or equal to <paramref name="clip_norm" />, then <paramref name="x" />
    ///             is not modified. If the average L2-norm is greater than <paramref name="clip_norm" />, then this operation returns a tensor of the same
    ///             type and shape as <paramref name="x" /> with its values set to: <c>t* clip_norm / l2norm_avg(t)</c>. In this case, 
    ///             the average L2-norm of the output tensor is <paramref name="clip_norm" />.
    ///             </remarks><param name="x">The input tensor.</param><param name="clip_norm">A maximum clipping value.</param><param name="operName">Name of the oper.</param>
    member this.ClipByAverageNorm(x : TF, clip_norm : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ClipByAverageNorm(x.TFOutput, clip_norm.TFOutput, operName))
    /// <summary>
    ///               Computes sigmoid cross entropy given `logits`.
    ///             </summary><remarks>
    ///                Measures the probability error in discrete classification tasks in which each
    ///                class is independent and not mutually exclusive.For instance, one could
    ///                perform multilabel classification where a picture can contain both an elephant
    ///                and a dog at the same time.
    ///             </remarks>
    member this.SigmoidCrossEntropyWithLogits(labels : TF, logits : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SigmoidCrossEntropyWithLogits(labels.TFOutput, logits.TFOutput, operName))
    /// <summary>
    ///               Shuffle dimensions of x according to a permutation.
    ///             </summary><param name="x"></param><param name="perm"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Transpose'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The output <c>y</c> has the same rank as <c>x</c>. The shapes of <c>x</c> and <c>y</c> satisfy:
    ///               <c>y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]</c></remarks>
    member this.Transpose(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Transpose(x.TFOutput, operName))
    /// <summary>
    ///               A conditional accumulator for aggregating gradients.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ConditionalAccumulator'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this accumulator is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this accumulator will be shared under the
    ///               given name across multiple sessions.
    ///             </param><param name="reduction_type">
    ///               Optional argument
    ///             </param><param name="dtype">
    ///               The type of the value being accumulated.
    ///             </param><param name="shape">
    ///               The shape of the values, can be [], in which case shape is unknown.
    ///             </param><returns>
    ///               The handle to the accumulator.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The accumulator accepts gradients marked with local_step greater or
    ///               equal to the most recent global_step known to the accumulator. The
    ///               average can be extracted from the accumulator, provided sufficient
    ///               gradients have been accumulated. Extracting the average automatically
    ///               resets the aggregate to 0, and increments the global_step recorded by
    ///               the accumulator.
    ///             </remarks>
    member this.Cond(pred : TF, true_fn : unit -> TF, false_fn : unit -> TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Cond(pred.TFOutput, (fun () -> (true_fn()).TFOutput), (fun () -> (false_fn()).TFOutput), operName))
    /// <summary>
    ///               Deprecated, use StackV2.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Stack'.
    ///             </param><param name="stack_name">
    ///               Optional argument
    ///             </param><param name="elem_type"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Stack(values : TF[], ?axis : Nullable<Int32>, ?operName : String) =
        let axis = defaultArg axis (Nullable(0))
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Stack(values |> Array.map (fun x -> x.TFOutput), axis, operName))
    /// <summary>
    ///               Creates a sequence of numbers.
    ///             </summary><param name="start">
    ///               0-D (scalar). First entry in the sequence.
    ///             </param><param name="limit">
    ///               0-D (scalar). Upper limit of sequence, exclusive.
    ///             </param><param name="delta">
    ///               0-D (scalar). Optional. Default is 1. Number that increments <c>start</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Range'.
    ///             </param><returns>
    ///               1-D.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation creates a sequence of numbers that begins at <c>start</c> and
    ///               extends by increments of <c>delta</c> up to but not including <c>limit</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 'start' is 3
    ///               # 'limit' is 18
    ///               # 'delta' is 3
    ///               tf.range(start, limit, delta) ==&amp;gt; [3, 6, 9, 12, 15]
    ///                </code></remarks>
    member this.Range(start : TF, ?limit : TF, ?delta : TF, ?dataType : TFDataType, ?operName : String) =
        let dataType = defaultArg (dataType |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName "range"
        TF(this.TFGraph, this.TFGraph.Range(start.TFOutput, limit |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, delta |> Option.map (fun x -> x.TFOutput) |> Option.toNullable, dataType, operName))
    /// <summary>
    ///               Returns a tensor of zeros with the same shape and type as x.
    ///             </summary><param name="x">
    ///               a tensor of type T.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ZerosLike'.
    ///             </param><returns>
    ///               a tensor of the same shape and type as x but filled with zeros.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Zeros(shape : TFShape, ?dtype : TFDataType, ?operName : String) =
        let dtype = defaultArg dtype TFDataType.Double
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Zeros(shape, dtype, operName))
    /// <summary>
    ///               Returns a tensor of ones with the same shape and type as x.
    ///             </summary><param name="x">
    ///               a tensor of type T.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'OnesLike'.
    ///             </param><returns>
    ///               a tensor of the same shape and type as x but filled with ones.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Ones(shape : TFShape, ?dtype : TFDataType, ?operName : String) =
        let dtype = defaultArg dtype TFDataType.Double
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Ones(shape, dtype, operName))
    /// <summary>
    ///             Create a constant tensor based on a shape
    ///             Used by Zeros and Ones
    ///             </summary><param name="value">Value for tensor</param><param name="tfshape">Shape of the tensor</param><param name="dtype">Optional Type of the Zero value. Default: Double</param><param name="operName">Operation name, optional.</param><returns></returns>
    ///             see https://github.com/tensorflow/tensorflow/blob/r1.1/tensorflow/python/framework/constant_op.py
    ///         
    member this.Constant(value : Object, tfshape : TFShape, ?dtype : TFDataType, ?operName : String) =
        let dtype = defaultArg dtype TFDataType.Double
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Constant(value, tfshape, dtype, operName))
    /// <summary>
    ///             Outputs random values from a normal distribution
    ///             </summary><returns>A tensor of the specified shape filled with random normal values.</returns><param name="shape">Shape of the output tensor.</param><param name="mean">The mean of the standard distribution.</param><param name="stddev">The standard deviation of the normal distribution.</param><param name="seed">Integer seed used for the random distribution, using the TensorFlow SetRandomSeed .</param><param name="operName">Operation name, optional.</param>
    member this.RandomNormal(shape : TFShape, ?mean : Double, ?stddev : Double, ?seed : Int32, ?operName : String) =
        let mean = defaultArg mean 0.000000
        let stddev = defaultArg stddev 1.000000
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomNormal(shape, mean, stddev, seed, operName))
    /// <summary>
    ///               Outputs random values from a uniform distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomUniform'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="dtype">
    ///               The type of the output.
    ///             </param><returns>
    ///               A tensor of the specified shape filled with uniform random values.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values follow a uniform distribution in the range <c>[0, 1)</c>. The
    ///               lower bound 0 is included in the range, while the upper bound 1 is excluded.
    ///             </remarks>
    member this.RandomUniform(shape : TFShape, ?minval : Double, ?maxval : Double, ?seed : Int32, ?operName : String) =
        let minval = defaultArg minval 0.000000
        let maxval = defaultArg maxval 1.000000
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomUniform(shape, minval, maxval, seed, operName))
    /// <summary>
    ///               Outputs random values from a uniform distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomUniform'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="dtype">
    ///               The type of the output.
    ///             </param><returns>
    ///               A tensor of the specified shape filled with uniform random values.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values follow a uniform distribution in the range <c>[0, 1)</c>. The
    ///               lower bound 0 is included in the range, while the upper bound 1 is excluded.
    ///             </remarks>
    member this.RandomUniform(shape : TFShape, ?minval : Single, ?maxval : Single, ?seed : Int32, ?operName : String) =
        let minval = defaultArg minval 0.000000f
        let maxval = defaultArg maxval 1.000000f
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomUniform(shape, minval, maxval, seed, operName))
    /// <summary>
    ///             Sets the tensor shape of the tensor referenced by <paramref name="output" /> to the shape described by <paramref name="dims" />.
    ///             </summary><param name="output">The tensor on which this method will operate in the graph.</param><param name="dims">The tensor shape, specified as an array of dimensions.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.SetTensorShape(output : TF, dims : Int64[], ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.SetTensorShape(output.TFOutput, dims, status)
    /// <summary>
    ///             Returns the number of dimensions of the Tensor referenced by output
    ///             </summary><returns>The number of dimensions of the tensor.</returns><param name="output">The tensor to probe.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.GetTensorNumDims(output : TF, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.GetTensorNumDims(output.TFOutput, status)
    /// <summary>
    ///              Returns the shape of a tensor specified in <paramref name="output" />.
    ///              </summary><returns>The tensor shape.    If the number of dimensions in the shape is unknown or the shape is, a scalar, the values in the array will be zero. Otherwise, each element of will be set corresponding to the size of the dimension. An  unknown dimension is represented by -1.</returns><param name="output">The tensor that you want to look up.  </param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.GetTensorShape(output : TF, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.GetTensorShape(output.TFOutput, status)
    /// <summary>
    ///             Write out a serialized representation of the graph (as a GraphDef protocol buffer message) into <paramref name="outputGraphDef" />.
    ///             </summary><param name="outputGraphDef">Target buffer where the graphs is serialized into.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.ToGraphDef(outputGraphDef : TFBuffer, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.ToGraphDef(outputGraphDef, status)
    /// <summary>
    ///             Import a serialized graph into this graph, using the specified prefix.
    ///             </summary><returns>The import.</returns><param name="graphDef">A buffer containing the serialized graph.</param><param name="prefix">A prefix that will be prepended to names of nodes in the <paramref name="graphDef" /> when they are imported into the graph.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.Import(graphDef : TFBuffer, ?prefix : String, ?status : TFStatus) =
        let prefix = defaultArg prefix ""
        let status = defaultArg status null
        this.TFGraph.Import(graphDef, prefix, status)
    /// <summary>
    ///             Import a serialized graph into this graph, using the specified prefix.
    ///             </summary><returns>The import.</returns><param name="graphDef">A buffer containing the serialized graph.</param><param name="prefix">A prefix that will be prepended to names of nodes in the <paramref name="graphDef" /> when they are imported into the graph.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.Import(graphDef : TFBuffer, options : TFImportGraphDefOptions, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.Import(graphDef, options, status)
    /// <summary>
    ///             Import a serialized graph into this graph, using the specified prefix.
    ///             </summary><returns>The import.</returns><param name="graphDef">A buffer containing the serialized graph.</param><param name="prefix">A prefix that will be prepended to names of nodes in the <paramref name="graphDef" /> when they are imported into the graph.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.Import(buffer : Byte[], ?prefix : String, ?status : TFStatus) =
        let prefix = defaultArg prefix ""
        let status = defaultArg status null
        this.TFGraph.Import(buffer, prefix, status)
    /// <summary>
    ///             Import a serialized graph into this graph, using the specified prefix.
    ///             </summary><returns>The import.</returns><param name="graphDef">A buffer containing the serialized graph.</param><param name="prefix">A prefix that will be prepended to names of nodes in the <paramref name="graphDef" /> when they are imported into the graph.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.Import(buffer : Byte[], options : TFImportGraphDefOptions, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.Import(buffer, options, status)
    member this.get_Item(name : String) =
        this.TFGraph.get_Item(name)
    /// <summary>
    ///             Returns the enumerator that returns all the TFOperations in a graph.
    ///             </summary><returns>The enumerator.</returns>
    member this.GetEnumerator() =
        this.TFGraph.GetEnumerator()
    /// <summary>
    ///              Returns the tensor shape for the specific output pparameters as an array of longs.
    ///             </summary><returns>null for single dimension, .</returns><param name="output">The output operation to probe.</param><param name="status">Status buffer, if specified a status code will be left here, if not specified, a <see cref="T:TensorFlow.TFException" /> exception is raised if there is an error.</param>
    member this.GetShape(output : TF, ?status : TFStatus) =
        let status = defaultArg status null
        this.TFGraph.GetShape(output.TFOutput, status)
    member this.get_CurrentNameScope() =
        this.TFGraph.get_CurrentNameScope()
    /// <summary>
    ///             Creates a new namescope by setting the scope to the description provided.
    ///             </summary><returns>A new scope that will remain in use until the return TFScope is disposed.</returns><param name="nameScopeDesc">The namescope description, if the value is null, this
    ///             will reset the toplevel namescope to be the empty value. </param><remarks><para>
    ///             To more easily name your operations and group then, you can use the
    ///             WithScope method to set a current name scope that alter the complete name
    ///             of an operation added to the graph.
    ///             </para><para>
    ///             The graph starts with a scope set to the empty string, you can introduce new
    ///             scopes by calling WithScope, and can be conveniently used with the C# using
    ///             statement, like this:
    ///             </para><code>
    ///             Assert (graph.CurrentNamescope, "");
    ///             using (var nested = graph.WithScope ("nested")){
    ///                Assert (graph.CurrentNameScope, "nested");
    ///                using (var inner = graph.WithScope ("inner")){
    ///                    Assert (graph.CurrentNameScope, "nested/inner");
    ///                }
    ///             }
    ///             </code></remarks>
    member this.WithScope(nameScopeDesc : String) =
        this.TFGraph.WithScope(nameScopeDesc)
    /// <summary>
    ///             Set the device to be used for all the operations defined in the using block.
    ///             Creates <see cref="T:TensorFlow.TFDevice" /> and sets <see cref="P:TensorFlow.TFGraph.DeviceName" /> to the intended device.
    ///             If device is already set throws exception.
    ///             </summary><param name="deviceName">Name of the device to be used e.g. "/cpu:0", "/device:GPU:0"</param>
    member this.WithDevice(deviceName : String) =
        this.TFGraph.WithDevice(deviceName)
    member this.get_CurrentDependencies() =
        this.TFGraph.get_CurrentDependencies()
    /// <summary>
    ///               Reorders a SparseTensor into the canonical, row-major ordering.
    ///             </summary><param name="input_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="input_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>input_indices</c>.
    ///             </param><param name="input_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseReorder'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices: 2-D.  <c>N x R</c> matrix with the same indices as input_indices, but
    ///               in canonical row-major ordering.
    ///               output_values: 1-D.  <c>N</c> non-empty values corresponding to <c>output_indices</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Note that by convention, all sparse ops preserve the canonical ordering along
    ///               increasing dimension number. The only time ordering can be violated is during
    ///               manual manipulation of the indices and values vectors to add entries.
    ///               
    ///               Reordering does not affect the shape of the SparseTensor.
    ///               
    ///               If the tensor has rank <c>R</c> and <c>N</c> non-empty values, <c>input_indices</c> has
    ///               shape <c>[N, R]</c>, input_values has length <c>N</c>, and input_shape has length <c>R</c>.
    ///             </remarks>
    member this.SparseReorder(input_indices : TF, input_values : TF, input_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseReorder(input_indices.TFOutput, input_values.TFOutput, input_shape.TFOutput, operName)
    /// <summary>
    ///               Reshapes a SparseTensor to represent values in a new dense shape.
    ///             </summary><param name="input_indices">
    ///               2-D.  <c>N x R_in</c> matrix with the indices of non-empty values in a
    ///               SparseTensor.
    ///             </param><param name="input_shape">
    ///               1-D.  <c>R_in</c> vector with the input SparseTensor's dense shape.
    ///             </param><param name="new_shape">
    ///               1-D.  <c>R_out</c> vector with the requested new dense shape.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseReshape'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices: 2-D.  <c>N x R_out</c> matrix with the updated indices of non-empty
    ///               values in the output SparseTensor.
    ///               output_shape: 1-D.  <c>R_out</c> vector with the full dense shape of the output
    ///               SparseTensor.  This is the same as <c>new_shape</c> but with any -1 dimensions
    ///               filled in.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This operation has the same semantics as reshape on the represented dense
    ///               tensor.  The <c>input_indices</c> are recomputed based on the requested <c>new_shape</c>.
    ///               
    ///               If one component of <c>new_shape</c> is the special value -1, the size of that
    ///               dimension is computed so that the total dense size remains constant.  At
    ///               most one component of <c>new_shape</c> can be -1.  The number of dense elements
    ///               implied by <c>new_shape</c> must be the same as the number of dense elements
    ///               originally implied by <c>input_shape</c>.
    ///               
    ///               Reshaping does not affect the order of values in the SparseTensor.
    ///               
    ///               If the input tensor has rank <c>R_in</c> and <c>N</c> non-empty values, and <c>new_shape</c>
    ///               has length <c>R_out</c>, then <c>input_indices</c> has shape <c>[N, R_in]</c>,
    ///               <c>input_shape</c> has length <c>R_in</c>, <c>output_indices</c> has shape <c>[N, R_out]</c>, and
    ///               <c>output_shape</c> has length <c>R_out</c>.
    ///             </remarks>
    member this.SparseReshape(input_indices : TF, input_shape : TF, new_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseReshape(input_indices.TFOutput, input_shape.TFOutput, new_shape.TFOutput, operName)
    /// <summary>
    ///               Computes the mean along sparse segments of a tensor.
    ///             </summary><param name="data"></param><param name="indices">
    ///               A 1-D tensor. Has same rank as <c>segment_ids</c>.
    ///             </param><param name="segment_ids">
    ///               A 1-D tensor. Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentMean'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Like <c>SegmentMean</c>, but <c>segment_ids</c> can have rank less than <c>data</c>'s first
    ///               dimension, selecting a subset of dimension 0, specified by <c>indices</c>.
    ///             </remarks>
    member this.SparseSegmentMean(data : TF, indices : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentMean(data.TFOutput, indices.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes gradients for SparseSegmentMean.
    ///             </summary><param name="grad">
    ///               gradient propagated to the SparseSegmentMean op.
    ///             </param><param name="indices">
    ///               indices passed to the corresponding SparseSegmentMean op.
    ///             </param><param name="segment_ids">
    ///               segment_ids passed to the corresponding SparseSegmentMean op.
    ///             </param><param name="output_dim0">
    ///               dimension 0 of "data" passed to SparseSegmentMean op.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentMeanGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Returns tensor "output" with same shape as grad, except for dimension 0 whose
    ///               value is output_dim0.
    ///             </remarks>
    member this.SparseSegmentMeanGrad(grad : TF, indices : TF, segment_ids : TF, output_dim0 : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentMeanGrad(grad.TFOutput, indices.TFOutput, segment_ids.TFOutput, output_dim0.TFOutput, operName))
    /// <summary>
    ///               Computes the mean along sparse segments of a tensor.
    ///             </summary><param name="data"></param><param name="indices">
    ///               A 1-D tensor. Has same rank as <c>segment_ids</c>.
    ///             </param><param name="segment_ids">
    ///               A 1-D tensor. Values should be sorted and can be repeated.
    ///             </param><param name="num_segments">
    ///               Should equal the number of distinct segment IDs.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentMeanWithNumSegments'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which has size
    ///               <c>num_segments</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Like <c>SparseSegmentMean</c>, but allows missing ids in <c>segment_ids</c>. If an id is
    ///               misisng, the <c>output</c> tensor at that position will be zeroed.
    ///               
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///             </remarks>
    member this.SparseSegmentMeanWithNumSegments(data : TF, indices : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentMeanWithNumSegments(data.TFOutput, indices.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Computes the sum along sparse segments of a tensor divided by the sqrt of N.
    ///             </summary><param name="data"></param><param name="indices">
    ///               A 1-D tensor. Has same rank as <c>segment_ids</c>.
    ///             </param><param name="segment_ids">
    ///               A 1-D tensor. Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentSqrtN'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               N is the size of the segment being reduced.
    ///               
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///             </remarks>
    member this.SparseSegmentSqrtN(data : TF, indices : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentSqrtN(data.TFOutput, indices.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes gradients for SparseSegmentSqrtN.
    ///             </summary><param name="grad">
    ///               gradient propagated to the SparseSegmentSqrtN op.
    ///             </param><param name="indices">
    ///               indices passed to the corresponding SparseSegmentSqrtN op.
    ///             </param><param name="segment_ids">
    ///               segment_ids passed to the corresponding SparseSegmentSqrtN op.
    ///             </param><param name="output_dim0">
    ///               dimension 0 of "data" passed to SparseSegmentSqrtN op.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentSqrtNGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Returns tensor "output" with same shape as grad, except for dimension 0 whose
    ///               value is output_dim0.
    ///             </remarks>
    member this.SparseSegmentSqrtNGrad(grad : TF, indices : TF, segment_ids : TF, output_dim0 : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentSqrtNGrad(grad.TFOutput, indices.TFOutput, segment_ids.TFOutput, output_dim0.TFOutput, operName))
    /// <summary>
    ///               Computes the sum along sparse segments of a tensor divided by the sqrt of N.
    ///             </summary><param name="data"></param><param name="indices">
    ///               A 1-D tensor. Has same rank as <c>segment_ids</c>.
    ///             </param><param name="segment_ids">
    ///               A 1-D tensor. Values should be sorted and can be repeated.
    ///             </param><param name="num_segments">
    ///               Should equal the number of distinct segment IDs.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentSqrtNWithNumSegments'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               N is the size of the segment being reduced.
    ///               
    ///               Like <c>SparseSegmentSqrtN</c>, but allows missing ids in <c>segment_ids</c>. If an id is
    ///               misisng, the <c>output</c> tensor at that position will be zeroed.
    ///               
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///             </remarks>
    member this.SparseSegmentSqrtNWithNumSegments(data : TF, indices : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentSqrtNWithNumSegments(data.TFOutput, indices.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Computes the sum along sparse segments of a tensor.
    ///             </summary><param name="data"></param><param name="indices">
    ///               A 1-D tensor. Has same rank as <c>segment_ids</c>.
    ///             </param><param name="segment_ids">
    ///               A 1-D tensor. Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentSum'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Like <c>SegmentSum</c>, but <c>segment_ids</c> can have rank less than <c>data</c>'s first
    ///               dimension, selecting a subset of dimension 0, specified by <c>indices</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
    ///               
    ///               # Select two rows, one segment.
    ///               tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
    ///               # =&amp;gt; [[0 0 0 0]]
    ///               
    ///               # Select two rows, two segment.
    ///               tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
    ///               # =&amp;gt; [[ 1  2  3  4]
    ///               #     [-1 -2 -3 -4]]
    ///               
    ///               # Select all rows, two segments.
    ///               tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
    ///               # =&amp;gt; [[0 0 0 0]
    ///               #     [5 6 7 8]]
    ///               
    ///               # Which is equivalent to:
    ///               tf.segment_sum(c, tf.constant([0, 0, 1]))
    ///                </code></remarks>
    member this.SparseSegmentSum(data : TF, indices : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentSum(data.TFOutput, indices.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes the sum along sparse segments of a tensor.
    ///             </summary><param name="data"></param><param name="indices">
    ///               A 1-D tensor. Has same rank as <c>segment_ids</c>.
    ///             </param><param name="segment_ids">
    ///               A 1-D tensor. Values should be sorted and can be repeated.
    ///             </param><param name="num_segments">
    ///               Should equal the number of distinct segment IDs.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSegmentSumWithNumSegments'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>num_segments</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Like <c>SparseSegmentSum</c>, but allows missing ids in <c>segment_ids</c>. If an id is
    ///               misisng, the <c>output</c> tensor at that position will be zeroed.
    ///               
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
    ///               
    ///               tf.sparse_segment_sum_with_num_segments(
    ///               c, tf.constant([0, 1]), tf.constant([0, 0]), num_segments=3)
    ///               # =&amp;gt; [[0 0 0 0]
    ///               #     [0 0 0 0]
    ///               #     [0 0 0 0]]
    ///               
    ///               tf.sparse_segment_sum_with_num_segments(c,
    ///               tf.constant([0, 1]),
    ///               tf.constant([0, 2],
    ///               num_segments=4))
    ///               # =&amp;gt; [[ 1  2  3  4]
    ///               #     [ 0  0  0  0]
    ///               #     [-1 -2 -3 -4]
    ///               #     [ 0  0  0  0]]
    ///                </code></remarks>
    member this.SparseSegmentSumWithNumSegments(data : TF, indices : TF, segment_ids : TF, num_segments : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSegmentSumWithNumSegments(data.TFOutput, indices.TFOutput, segment_ids.TFOutput, num_segments.TFOutput, operName))
    /// <summary>
    ///               Slice a <c>SparseTensor</c> based on the <c>start</c> and <c>size</c>.
    ///             </summary><param name="indices">
    ///               2-D tensor represents the indices of the sparse tensor.
    ///             </param><param name="values">
    ///               1-D tensor represents the values of the sparse tensor.
    ///             </param><param name="shape">
    ///               1-D. tensor represents the shape of the sparse tensor.
    ///             </param><param name="start">
    ///               1-D. tensor represents the start of the slice.
    ///             </param><param name="size">
    ///               1-D. tensor represents the size of the slice.
    ///               output indices: A list of 1-D tensors represents the indices of the output
    ///               sparse tensors.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSlice'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices:
    ///               output_values: A list of 1-D tensors represents the values of the output sparse
    ///               tensors.
    ///               output_shape: A list of 1-D tensors represents the shape of the output sparse
    ///               tensors.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               For example, if the input is
    ///               
    ///               input_tensor = shape = [2, 7]
    ///               [    a   d e  ]
    ///               [b c          ]
    ///               
    ///               Graphically the output tensors are:
    ///               
    ///               sparse_slice([0, 0], [2, 4]) = shape = [2, 4]
    ///               [    a  ]
    ///               [b c    ]
    ///               
    ///               sparse_slice([0, 4], [2, 3]) = shape = [2, 3]
    ///               [ d e  ]
    ///               [      ]
    ///             </remarks>
    member this.SparseSlice(indices : TF, values : TF, shape : TF, start : TF, size : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseSlice(indices.TFOutput, values.TFOutput, shape.TFOutput, start.TFOutput, size.TFOutput, operName)
    /// <summary>
    ///               The gradient operator for the SparseSlice op.
    ///             </summary><param name="backprop_val_grad">
    ///               1-D. The gradient with respect to
    ///               the non-empty values of the sliced <c>SparseTensor</c>.
    ///             </param><param name="input_indices">
    ///               2-D.  The <c>indices</c> of the input <c>SparseTensor</c>.
    ///             </param><param name="input_start">
    ///               1-D. tensor represents the start of the slice.
    ///             </param><param name="output_indices">
    ///               2-D.  The <c>indices</c> of the sliced <c>SparseTensor</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSliceGrad'.
    ///             </param><returns>
    ///               1-D. The gradient with respect to the non-empty values of input <c>SparseTensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op takes in the upstream gradient w.r.t. non-empty values of
    ///               the sliced <c>SparseTensor</c>, and outputs the gradients w.r.t.
    ///               the non-empty values of input <c>SparseTensor</c>.
    ///             </remarks>
    member this.SparseSliceGrad(backprop_val_grad : TF, input_indices : TF, input_start : TF, output_indices : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSliceGrad(backprop_val_grad.TFOutput, input_indices.TFOutput, input_start.TFOutput, output_indices.TFOutput, operName))
    /// <summary>
    ///               Applies softmax to a batched N-D <c>SparseTensor</c>.
    ///             </summary><param name="sp_indices">
    ///               2-D.  <c>NNZ x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, in canonical ordering.
    ///             </param><param name="sp_values">
    ///               1-D.  <c>NNZ</c> non-empty values corresponding to <c>sp_indices</c>.
    ///             </param><param name="sp_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSoftmax'.
    ///             </param><returns>
    ///               1-D.  The <c>NNZ</c> values for the result <c>SparseTensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The inputs represent an N-D SparseTensor  with logical shape <c>[..., B, C]</c>
    ///               (where <c>N &amp;gt;= 2</c>), and with indices sorted in the canonical lexicographic order.
    ///               
    ///               This op is equivalent to applying the normal <c>tf.nn.softmax()</c> to each innermost
    ///               logical submatrix with shape <c>[B, C]</c>, but with the catch that *the implicitly
    ///               zero elements do not participate*.  Specifically, the algorithm is equivalent
    ///               to the following:
    ///               
    ///               (1) Applies <c>tf.nn.softmax()</c> to a densified view of each innermost submatrix
    ///               with shape <c>[B, C]</c>, along the size-C dimension;
    ///               (2) Masks out the original implicitly-zero locations;
    ///               (3) Renormalizes the remaining elements.
    ///               
    ///               Hence, the <c>SparseTensor</c> result has exactly the same non-zero indices and
    ///               shape.
    ///             </remarks>
    member this.SparseSoftmax(sp_indices : TF, sp_values : TF, sp_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseSoftmax(sp_indices.TFOutput, sp_values.TFOutput, sp_shape.TFOutput, operName))
    /// <summary>
    ///               Computes softmax cross entropy cost and gradients to backpropagate.
    ///             </summary><param name="features">
    ///               batch_size x num_classes matrix
    ///             </param><param name="labels">
    ///               batch_size vector with values in [0, num_classes).
    ///               This is the label for the given minibatch entry.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSoftmaxCrossEntropyWithLogits'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               loss: Per example loss (batch_size vector).
    ///               backprop: backpropagated gradients (batch_size x num_classes matrix).
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Unlike <c>SoftmaxCrossEntropyWithLogits</c>, this operation does not accept
    ///               a matrix of label probabilities, but rather a single label per row
    ///               of features.  This label is considered to have probability 1.0 for the
    ///               given row.
    ///               
    ///               Inputs are the logits, not probabilities.
    ///             </remarks>
    member this.SparseSoftmaxCrossEntropyWithLogits(features : TF, labels : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseSoftmaxCrossEntropyWithLogits(features.TFOutput, labels.TFOutput, operName)
    /// <summary>
    ///               Returns the element-wise max of two SparseTensors.
    ///             </summary><param name="a_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, in the canonical lexicographic ordering.
    ///             </param><param name="a_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>a_indices</c>.
    ///             </param><param name="a_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="b_indices">
    ///               counterpart to <c>a_indices</c> for the other operand.
    ///             </param><param name="b_values">
    ///               counterpart to <c>a_values</c> for the other operand; must be of the same dtype.
    ///             </param><param name="b_shape">
    ///               counterpart to <c>a_shape</c> for the other operand; the two shapes must be equal.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSparseMaximum'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices: 2-D.  The indices of the output SparseTensor.
    ///               output_values: 1-D.  The values of the output SparseTensor.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
    ///             </remarks>
    member this.SparseSparseMaximum(a_indices : TF, a_values : TF, a_shape : TF, b_indices : TF, b_values : TF, b_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseSparseMaximum(a_indices.TFOutput, a_values.TFOutput, a_shape.TFOutput, b_indices.TFOutput, b_values.TFOutput, b_shape.TFOutput, operName)
    /// <summary>
    ///               Returns the element-wise min of two SparseTensors.
    ///             </summary><param name="a_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, in the canonical lexicographic ordering.
    ///             </param><param name="a_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>a_indices</c>.
    ///             </param><param name="a_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="b_indices">
    ///               counterpart to <c>a_indices</c> for the other operand.
    ///             </param><param name="b_values">
    ///               counterpart to <c>a_values</c> for the other operand; must be of the same dtype.
    ///             </param><param name="b_shape">
    ///               counterpart to <c>a_shape</c> for the other operand; the two shapes must be equal.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSparseMinimum'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices: 2-D.  The indices of the output SparseTensor.
    ///               output_values: 1-D.  The values of the output SparseTensor.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
    ///             </remarks>
    member this.SparseSparseMinimum(a_indices : TF, a_values : TF, a_shape : TF, b_indices : TF, b_values : TF, b_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseSparseMinimum(a_indices.TFOutput, a_values.TFOutput, a_shape.TFOutput, b_indices.TFOutput, b_values.TFOutput, b_shape.TFOutput, operName)
    /// <summary>
    ///               Split a <c>SparseTensor</c> into <c>num_split</c> tensors along one dimension.
    ///             </summary><param name="split_dim">
    ///               0-D.  The dimension along which to split.  Must be in the range
    ///               <c>[0, rank(shape))</c>.
    ///             </param><param name="indices">
    ///               2-D tensor represents the indices of the sparse tensor.
    ///             </param><param name="values">
    ///               1-D tensor represents the values of the sparse tensor.
    ///             </param><param name="shape">
    ///               1-D. tensor represents the shape of the sparse tensor.
    ///               output indices: A list of 1-D tensors represents the indices of the output
    ///               sparse tensors.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseSplit'.
    ///             </param><param name="num_split">
    ///               The number of ways to split.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices:
    ///               output_values: A list of 1-D tensors represents the values of the output sparse
    ///               tensors.
    ///               output_shape: A list of 1-D tensors represents the shape of the output sparse
    ///               tensors.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               If the <c>shape[split_dim]</c> is not an integer multiple of <c>num_split</c>. Slices
    ///               <c>[0 : shape[split_dim] % num_split]</c> gets one extra dimension.
    ///               For example, if <c>split_dim = 1</c> and <c>num_split = 2</c> and the input is
    ///               
    ///               input_tensor = shape = [2, 7]
    ///               [    a   d e  ]
    ///               [b c          ]
    ///               
    ///               Graphically the output tensors are:
    ///               
    ///               output_tensor[0] = shape = [2, 4]
    ///               [    a  ]
    ///               [b c    ]
    ///               
    ///               output_tensor[1] = shape = [2, 3]
    ///               [ d e  ]
    ///               [      ]
    ///             </remarks>
    member this.SparseSplit(split_dim : TF, indices : TF, values : TF, shape : TF, num_split : Int64, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseSplit(split_dim.TFOutput, indices.TFOutput, values.TFOutput, shape.TFOutput, num_split, operName)
    /// <summary>
    ///               Adds up a <c>SparseTensor</c> and a dense <c>Tensor</c>, producing a dense <c>Tensor</c>.
    ///             </summary><param name="a_indices">
    ///               2-D.  The <c>indices</c> of the <c>SparseTensor</c>, with shape <c>[nnz, ndims]</c>.
    ///             </param><param name="a_values">
    ///               1-D.  The <c>values</c> of the <c>SparseTensor</c>, with shape <c>[nnz]</c>.
    ///             </param><param name="a_shape">
    ///               1-D.  The <c>shape</c> of the <c>SparseTensor</c>, with shape <c>[ndims]</c>.
    ///             </param><param name="b"><c>ndims</c>-D Tensor.  With shape <c>a_shape</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseTensorDenseAdd'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This Op does not require <c>a_indices</c> be sorted in standard lexicographic order.
    ///             </remarks>
    member this.SparseTensorDenseAdd(a_indices : TF, a_values : TF, a_shape : TF, b : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseTensorDenseAdd(a_indices.TFOutput, a_values.TFOutput, a_shape.TFOutput, b.TFOutput, operName))
    /// <summary>
    ///               Multiply SparseTensor (of rank 2) "A" by dense matrix "B".
    ///             </summary><param name="a_indices">
    ///               2-D.  The <c>indices</c> of the <c>SparseTensor</c>, size <c>[nnz, 2]</c> Matrix.
    ///             </param><param name="a_values">
    ///               1-D.  The <c>values</c> of the <c>SparseTensor</c>, size <c>[nnz]</c> Vector.
    ///             </param><param name="a_shape">
    ///               1-D.  The <c>shape</c> of the <c>SparseTensor</c>, size <c>[2]</c> Vector.
    ///             </param><param name="b">
    ///               2-D.  A dense Matrix.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseTensorDenseMatMul'.
    ///             </param><param name="adjoint_a">
    ///               Optional argument
    ///               Use the adjoint of A in the matrix multiply.  If A is complex, this
    ///               is transpose(conj(A)).  Otherwise it's transpose(A).
    ///             </param><param name="adjoint_b">
    ///               Optional argument
    ///               Use the adjoint of B in the matrix multiply.  If B is complex, this
    ///               is transpose(conj(B)).  Otherwise it's transpose(B).
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               No validity checking is performed on the indices of A.  However, the following
    ///               input format is recommended for optimal behavior:
    ///               
    ///               if adjoint_a == false:
    ///               A should be sorted in lexicographically increasing order.  Use SparseReorder
    ///               if you're not sure.
    ///               if adjoint_a == true:
    ///               A should be sorted in order of increasing dimension 1 (i.e., "column major"
    ///               order instead of "row major" order).
    ///             </remarks>
    member this.SparseTensorDenseMatMul(a_indices : TF, a_values : TF, a_shape : TF, b : TF, ?adjoint_a : Boolean, ?adjoint_b : Boolean, ?operName : String) =
        let adjoint_a = defaultArg (adjoint_a |> Option.map Nullable) (Nullable())
        let adjoint_b = defaultArg (adjoint_b |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseTensorDenseMatMul(a_indices.TFOutput, a_values.TFOutput, a_shape.TFOutput, b.TFOutput, adjoint_a, adjoint_b, operName))
    /// <summary>
    ///               Creates a dataset that splits a SparseTensor into elements row-wise.
    ///             </summary><param name="indices"></param><param name="values"></param><param name="dense_shape"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseTensorSliceDataset'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SparseTensorSliceDataset(indices : TF, values : TF, dense_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseTensorSliceDataset(indices.TFOutput, values.TFOutput, dense_shape.TFOutput, operName))
    /// <summary>
    ///               Converts a sparse representation into a dense tensor.
    ///             </summary><param name="sparse_indices">
    ///               0-D, 1-D, or 2-D.  <c>sparse_indices[i]</c> contains the complete
    ///               index where <c>sparse_values[i]</c> will be placed.
    ///             </param><param name="output_shape">
    ///               1-D.  Shape of the dense output tensor.
    ///             </param><param name="sparse_values">
    ///               1-D.  Values corresponding to each row of <c>sparse_indices</c>,
    ///               or a scalar value to be used for all sparse indices.
    ///             </param><param name="default_value">
    ///               Scalar value to set for indices not specified in
    ///               <c>sparse_indices</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseToDense'.
    ///             </param><param name="validate_indices">
    ///               Optional argument
    ///               If true, indices are checked to make sure they are sorted in
    ///               lexicographic order and that there are no repeats.
    ///             </param><returns>
    ///               Dense output tensor of shape <c>output_shape</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Builds an array <c>dense</c> with shape <c>output_shape</c> such that
    ///               
    ///                <code>
    ///               # If sparse_indices is scalar
    ///               dense[i] = (i == sparse_indices ? sparse_values : default_value)
    ///               
    ///               # If sparse_indices is a vector, then for each i
    ///               dense[sparse_indices[i]] = sparse_values[i]
    ///               
    ///               # If sparse_indices is an n by d matrix, then for each i in [0, n)
    ///               dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
    ///                </code>
    ///               
    ///               All other values in <c>dense</c> are set to <c>default_value</c>.  If <c>sparse_values</c> is a
    ///               scalar, all sparse indices are set to this single value.
    ///               
    ///               Indices should be sorted in lexicographic order, and indices must not
    ///               contain any repeats. If <c>validate_indices</c> is true, these properties
    ///               are checked during execution.
    ///             </remarks>
    member this.SparseToDense(sparse_indices : TF, output_shape : TF, sparse_values : TF, default_value : TF, ?validate_indices : Boolean, ?operName : String) =
        let validate_indices = defaultArg (validate_indices |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseToDense(sparse_indices.TFOutput, output_shape.TFOutput, sparse_values.TFOutput, default_value.TFOutput, validate_indices, operName))
    /// <summary>
    ///               Applies set operation along last dimension of 2 <c>SparseTensor</c> inputs.
    ///             </summary><param name="set1_indices">
    ///               2D <c>Tensor</c>, indices of a <c>SparseTensor</c>. Must be in row-major
    ///               order.
    ///             </param><param name="set1_values">
    ///               1D <c>Tensor</c>, values of a <c>SparseTensor</c>. Must be in row-major
    ///               order.
    ///             </param><param name="set1_shape">
    ///               1D <c>Tensor</c>, shape of a <c>SparseTensor</c>. <c>set1_shape[0...n-1]</c> must
    ///               be the same as <c>set2_shape[0...n-1]</c>, <c>set1_shape[n]</c> is the
    ///               max set size across <c>0...n-1</c> dimensions.
    ///             </param><param name="set2_indices">
    ///               2D <c>Tensor</c>, indices of a <c>SparseTensor</c>. Must be in row-major
    ///               order.
    ///             </param><param name="set2_values">
    ///               1D <c>Tensor</c>, values of a <c>SparseTensor</c>. Must be in row-major
    ///               order.
    ///             </param><param name="set2_shape">
    ///               1D <c>Tensor</c>, shape of a <c>SparseTensor</c>. <c>set2_shape[0...n-1]</c> must
    ///               be the same as <c>set1_shape[0...n-1]</c>, <c>set2_shape[n]</c> is the
    ///               max set size across <c>0...n-1</c> dimensions.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseToSparseSetOperation'.
    ///             </param><param name="validate_indices">
    ///               Optional argument
    ///             </param><param name="set_operation"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               result_indices: 2D indices of a <c>SparseTensor</c>.
    ///               result_values: 1D values of a <c>SparseTensor</c>.
    ///               result_shape: 1D <c>Tensor</c> shape of a <c>SparseTensor</c>. <c>result_shape[0...n-1]</c> is
    ///               the same as the 1st <c>n-1</c> dimensions of <c>set1</c> and <c>set2</c>, <c>result_shape[n]</c>
    ///               is the max result set size across all <c>0...n-1</c> dimensions.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               See SetOperationOp::SetOperationFromContext for values of <c>set_operation</c>.
    ///               
    ///               If <c>validate_indices</c> is <c>True</c>, <c>SparseToSparseSetOperation</c> validates the
    ///               order and range of <c>set1</c> and <c>set2</c> indices.
    ///               
    ///               Input <c>set1</c> is a <c>SparseTensor</c> represented by <c>set1_indices</c>, <c>set1_values</c>,
    ///               and <c>set1_shape</c>. For <c>set1</c> ranked <c>n</c>, 1st <c>n-1</c> dimensions must be the same
    ///               as <c>set2</c>. Dimension <c>n</c> contains values in a set, duplicates are allowed but
    ///               ignored.
    ///               
    ///               Input <c>set2</c> is a <c>SparseTensor</c> represented by <c>set2_indices</c>, <c>set2_values</c>,
    ///               and <c>set2_shape</c>. For <c>set2</c> ranked <c>n</c>, 1st <c>n-1</c> dimensions must be the same
    ///               as <c>set1</c>. Dimension <c>n</c> contains values in a set, duplicates are allowed but
    ///               ignored.
    ///               
    ///               If <c>validate_indices</c> is <c>True</c>, this op validates the order and range of <c>set1</c>
    ///               and <c>set2</c> indices.
    ///               
    ///               Output <c>result</c> is a <c>SparseTensor</c> represented by <c>result_indices</c>,
    ///               <c>result_values</c>, and <c>result_shape</c>. For <c>set1</c> and <c>set2</c> ranked <c>n</c>, this
    ///               has rank <c>n</c> and the same 1st <c>n-1</c> dimensions as <c>set1</c> and <c>set2</c>. The <c>nth</c>
    ///               dimension contains the result of <c>set_operation</c> applied to the corresponding
    ///               <c>[0...n-1]</c> dimension of <c>set</c>.
    ///             </remarks>
    member this.SparseToSparseSetOperation(set1_indices : TF, set1_values : TF, set1_shape : TF, set2_indices : TF, set2_values : TF, set2_shape : TF, set_operation : String, ?validate_indices : Boolean, ?operName : String) =
        let validate_indices = defaultArg (validate_indices |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SparseToSparseSetOperation(set1_indices.TFOutput, set1_values.TFOutput, set1_shape.TFOutput, set2_indices.TFOutput, set2_values.TFOutput, set2_shape.TFOutput, set_operation, validate_indices, operName)
    /// <summary>
    ///               Splits a tensor into <c>num_split</c> tensors along one dimension.
    ///             </summary><param name="split_dim">
    ///               0-D.  The dimension along which to split.  Must be in the range
    ///               <c>[-rank(value), rank(value))</c>.
    ///             </param><param name="value">
    ///               The tensor to split.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Split'.
    ///             </param><param name="num_split">
    ///               The number of ways to split.  Must evenly divide
    ///               <c>value.shape[split_dim]</c>.
    ///             </param><returns>
    ///               They are identically shaped tensors, whose shape matches that of <c>value</c>
    ///               except along <c>axis</c>, where their sizes are
    ///               <c>values.shape[split_dim] / num_split</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Split(split_dim : TF, value : TF, num_split : Int64, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.Split(split_dim.TFOutput, value.TFOutput, num_split, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Splits a tensor into <c>num_split</c> tensors along one dimension.
    ///             </summary><param name="value">
    ///               The tensor to split.
    ///             </param><param name="size_splits">
    ///               list containing the sizes of each output tensor along the split
    ///               dimension. Must sum to the dimension of value along split_dim.
    ///               Can contain one -1 indicating that dimension is to be inferred.
    ///             </param><param name="split_dim">
    ///               0-D.  The dimension along which to split.  Must be in the range
    ///               <c>[-rank(value), rank(value))</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SplitV'.
    ///             </param><param name="num_split"></param><returns>
    ///               Tensors whose shape matches that of <c>value</c>
    ///               except along <c>axis</c>, where their sizes are
    ///               <c>size_splits[i]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SplitV(value : TF, size_splits : TF, split_dim : TF, num_split : Int64, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SplitV(value.TFOutput, size_splits.TFOutput, split_dim.TFOutput, num_split, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Computes square root of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sqrt'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               I.e., \\(y = \sqrt{x} = x^{1/2}\\).
    ///             </remarks>
    member this.Sqrt(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sqrt(x.TFOutput, operName))
    /// <summary>
    ///               Computes the gradient for the sqrt of <c>x</c> wrt its input.
    ///             </summary><param name="y"></param><param name="dy"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SqrtGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Specifically, <c>grad = dy * 0.5 / y</c>, where <c>y = sqrt(x)</c>, and <c>dy</c>
    ///               is the corresponding input gradient.
    ///             </remarks>
    member this.SqrtGrad(y : TF, dy : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SqrtGrad(y.TFOutput, dy.TFOutput, operName))
    /// <summary>
    ///               Computes square of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Square'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               I.e., \\(y = x * x = x^2\\).
    ///             </remarks>
    member this.Square(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Square(x.TFOutput, operName))
    /// <summary>
    ///               Returns (x - y)(x - y) element-wise.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SquaredDifference'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               *NOTE*: <c>SquaredDifference</c> supports broadcasting. More about broadcasting
    ///               [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///             </remarks>
    member this.SquaredDifference(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SquaredDifference(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Removes dimensions of size 1 from the shape of a tensor.
    ///             </summary><param name="input">
    ///               The <c>input</c> to squeeze.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Squeeze'.
    ///             </param><param name="squeeze_dims">
    ///               Optional argument
    ///               If specified, only squeezes the dimensions listed. The dimension
    ///               index starts at 0. It is an error to squeeze a dimension that is not 1. Must
    ///               be in the range <c>[-rank(input), rank(input))</c>.
    ///             </param><returns>
    ///               Contains the same data as <c>input</c>, but has one or more dimensions of
    ///               size 1 removed.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Given a tensor <c>input</c>, this operation returns a tensor of the same type with
    ///               all dimensions of size 1 removed. If you don't want to remove all size 1
    ///               dimensions, you can remove specific size 1 dimensions by specifying
    ///               <c>axis</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
    ///               shape(squeeze(t)) ==&amp;gt; [2, 3]
    ///                </code>
    ///               
    ///               Or, to remove specific size 1 dimensions:
    ///               
    ///                <code>
    ///               # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
    ///               shape(squeeze(t, [2, 4])) ==&amp;gt; [1, 2, 3, 1]
    ///                </code></remarks>
    member this.Squeeze(input : TF, ?squeeze_dims : Int64[], ?operName : String) =
        let squeeze_dims = defaultArg squeeze_dims null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Squeeze(input.TFOutput, squeeze_dims, operName))
    /// <summary>
    ///               Deprecated, use StackV2.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Stack'.
    ///             </param><param name="stack_name">
    ///               Optional argument
    ///             </param><param name="elem_type"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Stack(elem_type : TFDataType, ?stack_name : String, ?operName : String) =
        let stack_name = defaultArg stack_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Stack(elem_type, stack_name, operName))
    /// <summary>
    ///               Deprecated, use StackCloseV2.
    ///             </summary><param name="handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackClose'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.StackClose(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.StackClose(handle.TFOutput, operName)
    /// <summary>
    ///               Delete the stack from its resource container.
    ///             </summary><param name="handle">
    ///               The handle to a stack.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackCloseV2'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.StackCloseV2(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.StackCloseV2(handle.TFOutput, operName)
    /// <summary>
    ///               Deprecated, use StackPopV2.
    ///             </summary><param name="handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackPop'.
    ///             </param><param name="elem_type"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StackPop(handle : TF, elem_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StackPop(handle.TFOutput, elem_type, operName))
    /// <summary>
    ///               Pop the element at the top of the stack.
    ///             </summary><param name="handle">
    ///               The handle to a stack.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackPopV2'.
    ///             </param><param name="elem_type">
    ///               The type of the elem that is popped.
    ///             </param><returns>
    ///               The tensor that is popped from the top of the stack.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StackPopV2(handle : TF, elem_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StackPopV2(handle.TFOutput, elem_type, operName))
    /// <summary>
    ///               Deprecated, use StackPushV2.
    ///             </summary><param name="handle"></param><param name="elem"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackPush'.
    ///             </param><param name="swap_memory">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StackPush(handle : TF, elem : TF, ?swap_memory : Boolean, ?operName : String) =
        let swap_memory = defaultArg (swap_memory |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StackPush(handle.TFOutput, elem.TFOutput, swap_memory, operName))
    /// <summary>
    ///               Push an element onto the stack.
    ///             </summary><param name="handle">
    ///               The handle to a stack.
    ///             </param><param name="elem">
    ///               The tensor to be pushed onto the stack.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackPushV2'.
    ///             </param><param name="swap_memory">
    ///               Optional argument
    ///               Swap <c>elem</c> to CPU. Default to false.
    ///             </param><returns>
    ///               The same tensor as the input 'elem'.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StackPushV2(handle : TF, elem : TF, ?swap_memory : Boolean, ?operName : String) =
        let swap_memory = defaultArg (swap_memory |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StackPushV2(handle.TFOutput, elem.TFOutput, swap_memory, operName))
    /// <summary>
    ///               A stack that produces elements in first-in last-out order.
    ///             </summary><param name="max_size">
    ///               The maximum size of the stack if non-negative. If negative, the stack
    ///               size is unlimited.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StackV2'.
    ///             </param><param name="stack_name">
    ///               Optional argument
    ///               Overrides the name used for the temporary stack resource. Default
    ///               value is the name of the 'Stack' op (which is guaranteed unique).
    ///             </param><param name="elem_type">
    ///               The type of the elements on the stack.
    ///             </param><returns>
    ///               The handle to the stack.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StackV2(max_size : TF, elem_type : TFDataType, ?stack_name : String, ?operName : String) =
        let stack_name = defaultArg stack_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StackV2(max_size.TFOutput, elem_type, stack_name, operName))
    /// <summary>
    ///               Stage values similar to a lightweight Enqueue.
    ///             </summary><param name="values">
    ///               a list of tensors
    ///               dtypes A list of data types that inserted values should adhere to.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Stage'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///               Maximum number of elements in the Staging Area. If &amp;gt; 0, inserts
    ///               on the container will block when the capacity is reached.
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///               The maximum number of bytes allowed for Tensors in the Staging Area.
    ///               If &amp;gt; 0, inserts will block until sufficient space is available.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this queue is placed in the given container. Otherwise,
    ///               a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               It is necessary to match this name to the matching Unstage Op.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The basic functionality of this Op is similar to a queue with many
    ///               fewer capabilities and options.  This Op is optimized for performance.
    ///             </remarks>
    member this.Stage(values : TF[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.Stage(values |> Array.map (fun x -> x.TFOutput), capacity, memory_limit, container, shared_name, operName)
    /// <summary>
    ///               Op removes all elements in the underlying container.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StageClear'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.StageClear(dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.StageClear(dtypes, capacity, memory_limit, container, shared_name, operName)
    /// <summary>
    ///               Op peeks at the values at the specified index.  If the
    ///             </summary><param name="index"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StagePeek'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               underlying container does not contain sufficient elements
    ///               this op will block until it does.   This Op is optimized for
    ///               performance.
    ///             </remarks>
    member this.StagePeek(index : TF, dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.StagePeek(index.TFOutput, dtypes, capacity, memory_limit, container, shared_name, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Op returns the number of elements in the underlying container.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StageSize'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StageSize(dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StageSize(dtypes, capacity, memory_limit, container, shared_name, operName))
    /// <summary>
    ///               Draws samples from a multinomial distribution.
    ///             </summary><param name="logits">
    ///               2-D Tensor with shape <c>[batch_size, num_classes]</c>.  Each slice <c>[i, :]</c>
    ///               represents the unnormalized log probabilities for all classes.
    ///             </param><param name="num_samples">
    ///               0-D.  Number of independent samples to draw for each row slice.
    ///             </param><param name="seed">
    ///               2 seeds (shape [2]).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StatelessMultinomial'.
    ///             </param><param name="output_dtype">
    ///               Optional argument
    ///             </param><returns>
    ///               2-D Tensor with shape <c>[batch_size, num_samples]</c>.  Each slice <c>[i, :]</c>
    ///               contains the drawn class labels with range <c>[0, num_classes)</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StatelessMultinomial(logits : TF, num_samples : TF, seed : TF, ?output_dtype : TFDataType, ?operName : String) =
        let output_dtype = defaultArg (output_dtype |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StatelessMultinomial(logits.TFOutput, num_samples.TFOutput, seed.TFOutput, output_dtype, operName))
    /// <summary>
    ///               Outputs deterministic pseudorandom values from a normal distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="seed">
    ///               2 seeds (shape [2]).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StatelessRandomNormal'.
    ///             </param><param name="dtype">
    ///               Optional argument
    ///               The type of the output.
    ///             </param><returns>
    ///               Random values with specified shape.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values will have mean 0 and standard deviation 1.
    ///               
    ///               The outputs are a deterministic function of <c>shape</c> and <c>seed</c>.
    ///             </remarks>
    member this.StatelessRandomNormal(shape : TF, seed : TF, ?dtype : TFDataType, ?operName : String) =
        let dtype = defaultArg (dtype |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StatelessRandomNormal(shape.TFOutput, seed.TFOutput, dtype, operName))
    /// <summary>
    ///               Outputs deterministic pseudorandom random values from a uniform distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="seed">
    ///               2 seeds (shape [2]).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StatelessRandomUniform'.
    ///             </param><param name="dtype">
    ///               Optional argument
    ///               The type of the output.
    ///             </param><returns>
    ///               Random values with specified shape.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values follow a uniform distribution in the range <c>[0, 1)</c>. The
    ///               lower bound 0 is included in the range, while the upper bound 1 is excluded.
    ///               
    ///               The outputs are a deterministic function of <c>shape</c> and <c>seed</c>.
    ///             </remarks>
    member this.StatelessRandomUniform(shape : TF, seed : TF, ?dtype : TFDataType, ?operName : String) =
        let dtype = defaultArg (dtype |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StatelessRandomUniform(shape.TFOutput, seed.TFOutput, dtype, operName))
    /// <summary>
    ///               Outputs deterministic pseudorandom values from a truncated normal distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="seed">
    ///               2 seeds (shape [2]).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StatelessTruncatedNormal'.
    ///             </param><param name="dtype">
    ///               Optional argument
    ///               The type of the output.
    ///             </param><returns>
    ///               Random values with specified shape.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values follow a normal distribution with mean 0 and standard
    ///               deviation 1, except that values whose magnitude is more than 2 standard
    ///               deviations from the mean are dropped and re-picked.
    ///               
    ///               The outputs are a deterministic function of <c>shape</c> and <c>seed</c>.
    ///             </remarks>
    member this.StatelessTruncatedNormal(shape : TF, seed : TF, ?dtype : TFDataType, ?operName : String) =
        let dtype = defaultArg (dtype |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StatelessTruncatedNormal(shape.TFOutput, seed.TFOutput, dtype, operName))
    /// <summary>
    ///               Check if the input matches the regex pattern.
    ///             </summary><param name="input">
    ///               A string tensor of the text to be processed.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StaticRegexFullMatch'.
    ///             </param><param name="pattern">
    ///               The regular expression to match the input.
    ///             </param><returns>
    ///               A bool tensor with the same shape as <c>input</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The input is a string tensor of any shape. The pattern is the
    ///               regular expression to be matched with every element of the input tensor.
    ///               The boolean values (True or False) of the output tensor indicate
    ///               if the input matches the regex pattern provided.
    ///               
    ///               The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
    ///             </remarks>
    member this.StaticRegexFullMatch(input : TF, pattern : String, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StaticRegexFullMatch(input.TFOutput, pattern, operName))
    /// <summary>
    ///               Replaces the match of pattern in input with rewrite.
    ///             </summary><param name="input">
    ///               The text to be processed.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StaticRegexReplace'.
    ///             </param><param name="replace_global">
    ///               Optional argument
    ///               If True, the replacement is global, otherwise the replacement
    ///               is done only on the first match.
    ///             </param><param name="pattern">
    ///               The regular expression to match the input.
    ///             </param><param name="rewrite">
    ///               The rewrite to be applied to the matched expresion.
    ///             </param><returns>
    ///               The text after applying pattern and rewrite.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
    ///             </remarks>
    member this.StaticRegexReplace(input : TF, pattern : String, rewrite : String, ?replace_global : Boolean, ?operName : String) =
        let replace_global = defaultArg (replace_global |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StaticRegexReplace(input.TFOutput, pattern, rewrite, replace_global, operName))
    /// <summary>
    ///               Stops gradient computation.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StopGradient'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               When executed in a graph, this op outputs its input tensor as-is.
    ///               
    ///               When building ops to compute gradients, this op prevents the contribution of
    ///               its inputs to be taken into account.  Normally, the gradient generator adds ops
    ///               to a graph to compute the derivatives of a specified 'loss' by recursively
    ///               finding out inputs that contributed to its computation.  If you insert this op
    ///               in the graph it inputs are masked from the gradient generator.  They are not
    ///               taken into account for computing gradients.
    ///               
    ///               This is useful any time you want to compute a value with TensorFlow but need
    ///               to pretend that the value was a constant. Some examples include:
    ///               
    ///               *  The *EM* algorithm where the *M-step* should not involve backpropagation
    ///               through the output of the *E-step*.
    ///               *  Contrastive divergence training of Boltzmann machines where, when
    ///               differentiating the energy function, the training must not backpropagate
    ///               through the graph that generated the samples from the model.
    ///               *  Adversarial training, where no backprop should happen through the adversarial
    ///               example generation process.
    ///             </remarks>
    member this.StopGradient(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StopGradient(input.TFOutput, operName))
    /// <summary>
    ///               Return a strided slice from <c>input</c>.
    ///             </summary><param name="input"></param><param name="begin"><c>begin[k]</c> specifies the offset into the <c>k</c>th range specification.
    ///               The exact dimension this corresponds to will be determined by context.
    ///               Out-of-bounds values will be silently clamped. If the <c>k</c>th bit of
    ///               <c>begin_mask</c> then <c>begin[k]</c> is ignored and the full range of the
    ///               appropriate dimension is used instead. Negative values causes indexing
    ///               to start from the highest element e.g. If <c>foo==[1,2,3]</c> then <c>foo[-1]==3</c>.
    ///             </param><param name="end"><c>end[i]</c> is like <c>begin</c> with the exception that <c>end_mask</c> is
    ///               used to determine full ranges.
    ///             </param><param name="strides"><c>strides[i]</c> specifies the increment in the <c>i</c>th specification
    ///               after extracting a given element. Negative indices will reverse
    ///               the original order. Out or range values are
    ///               clamped to <c>[0,dim[i]) if slice[i]&amp;gt;0</c> or <c>[-1,dim[i]-1] if slice[i] &amp;lt; 0</c></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StridedSlice'.
    ///             </param><param name="begin_mask">
    ///               Optional argument
    ///               a bitmask where a bit i being 1 means to ignore the begin
    ///               value and instead use the largest interval possible. At runtime
    ///               begin[i] will be replaced with <c>[0, n-1)</c> if <c>stride[i] &amp;gt; 0</c> or
    ///               <c>[-1, n-1]</c> if <c>stride[i] &amp;lt; 0</c></param><param name="end_mask">
    ///               Optional argument
    ///               analogous to <c>begin_mask</c></param><param name="ellipsis_mask">
    ///               Optional argument
    ///               a bitmask where bit <c>i</c> being 1 means the <c>i</c>th
    ///               position is actually an ellipsis. One bit at most can be 1.
    ///               If <c>ellipsis_mask == 0</c>, then an implicit ellipsis mask of <c>1 &amp;lt;&amp;lt; (m+1)</c>
    ///               is provided. This means that <c>foo[3:5] == foo[3:5, ...]</c>. An ellipsis
    ///               implicitly creates as many range specifications as necessary to fully
    ///               specify the sliced range for every dimension. For example for a 4-dimensional
    ///               tensor <c>foo</c> the slice <c>foo[2, ..., 5:8]</c> implies <c>foo[2, :, :, 5:8]</c>.
    ///             </param><param name="new_axis_mask">
    ///               Optional argument
    ///               a bitmask where bit <c>i</c> being 1 means the <c>i</c>th
    ///               specification creates a new shape 1 dimension. For example
    ///               <c>foo[:4, tf.newaxis, :2]</c> would produce a shape <c>(4, 1, 2)</c> tensor.
    ///             </param><param name="shrink_axis_mask">
    ///               Optional argument
    ///               a bitmask where bit <c>i</c> implies that the <c>i</c>th
    ///               specification should shrink the dimensionality. begin and end
    ///               must imply a slice of size 1 in the dimension. For example in
    ///               python one might do <c>foo[:, 3, :]</c> which would result in
    ///               <c>shrink_axis_mask</c> being 2.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Note, most python users will want to use the Python <c>Tensor.__getitem__</c>
    ///               or <c>Variable.__getitem__</c> rather than this op directly.
    ///               
    ///               The goal of this op is to produce a new tensor with a subset of
    ///               the elements from the <c>n</c> dimensional <c>input</c> tensor. The subset is chosen using
    ///               a sequence of <c>m</c> sparse range specifications encoded into the arguments
    ///               of this function. Note, in some cases
    ///               <c>m</c> could be equal to <c>n</c>, but this need not be the case. Each
    ///               range specification entry can be one of the following:
    ///               
    ///               - An ellipsis (...). Ellipses are used to imply zero or more
    ///               dimensions of full-dimension selection and are produced using
    ///               <c>ellipsis_mask</c>. For example, <c>foo[...]</c> is the identity slice.
    ///               
    ///               - A new axis. This is used to insert a new shape=1 dimension and is
    ///               produced using <c>new_axis_mask</c>. For example, <c>foo[:, ...]</c> where
    ///               <c>foo</c> is shape <c>(3, 4)</c> produces a <c>(1, 3, 4)</c> tensor.
    ///               
    ///               
    ///               - A range <c>begin:end:stride</c>. This is used to specify how much to choose from
    ///               a given dimension. <c>stride</c> can be any integer but 0.  <c>begin</c> is an integer
    ///               which represents the index of the first value to select while <c>end</c> represents
    ///               the index of the last value to select. The number of values selected in each
    ///               dimension is <c>end - begin</c> if <c>stride &amp;gt; 0</c> and <c>begin - end</c> if <c>stride &amp;lt; 0</c>.
    ///               <c>begin</c> and <c>end</c> can be negative where <c>-1</c> is the last element, <c>-2</c> is
    ///               the second to last. <c>begin_mask</c> controls whether to replace the explicitly
    ///               given <c>begin</c> with an implicit effective value of <c>0</c> if <c>stride &amp;gt; 0</c> and
    ///               <c>-1</c> if <c>stride &amp;lt; 0</c>. <c>end_mask</c> is analogous but produces the number
    ///               required to create the largest open interval. For example, given a shape
    ///               <c>(3,)</c> tensor <c>foo[:]</c>, the effective <c>begin</c> and <c>end</c> are <c>0</c> and <c>3</c>. Do
    ///               not assume this is equivalent to <c>foo[0:-1]</c> which has an effective <c>begin</c>
    ///               and <c>end</c> of <c>0</c> and <c>2</c>. Another example is <c>foo[-2::-1]</c> which reverses the
    ///               first dimension of a tensor while dropping the last two (in the original
    ///               order elements). For example <c>foo = [1,2,3,4]; foo[-2::-1]</c> is <c>[4,3]</c>.
    ///               
    ///               - A single index. This is used to keep only elements that have a given
    ///               index. For example (<c>foo[2, :]</c> on a shape <c>(5,6)</c> tensor produces a
    ///               shape <c>(6,)</c> tensor. This is encoded in <c>begin</c> and <c>end</c> and
    ///               <c>shrink_axis_mask</c>.
    ///               
    ///               Each conceptual range specification is encoded in the op's argument. This
    ///               encoding is best understand by considering a non-trivial example. In
    ///               particular,
    ///               <c>foo[1, 2:4, None, ..., :-3:-1, :]</c> will be encoded as
    ///               
    ///                <code>
    ///               begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
    ///               end = [2, 4, x, x, -3, x]
    ///               strides = [1, 1, x, x, -1, 1]
    ///               begin_mask = 1&amp;lt;&amp;lt;4 | 1 &amp;lt;&amp;lt; 5 = 48
    ///               end_mask = 1&amp;lt;&amp;lt;5 = 32
    ///               ellipsis_mask = 1&amp;lt;&amp;lt;3 = 8
    ///               new_axis_mask = 1&amp;lt;&amp;lt;2 4
    ///               shrink_axis_mask = 1&amp;lt;&amp;lt;0
    ///                </code>
    ///               
    ///               In this case if <c>foo.shape</c> is (5, 5, 5, 5, 5, 5) the final shape of
    ///               the slice becomes (2, 1, 5, 5, 2, 5).
    ///               Let us walk step by step through each argument specification.
    ///               
    ///               1.  The first argument in the example slice is turned into <c>begin = 1</c> and
    ///               <c>end = begin + 1 = 2</c>. To disambiguate from the original spec <c>2:4</c> we
    ///               also set the appropriate bit in <c>shrink_axis_mask</c>.
    ///               
    ///               2. <c>2:4</c> is contributes 2, 4, 1 to begin, end, and stride. All masks have
    ///               zero bits contributed.
    ///               
    ///               3. None is a synonym for <c>tf.newaxis</c>. This means insert a dimension of size 1
    ///               dimension in the final shape. Dummy values are contributed to begin,
    ///               end and stride, while the new_axis_mask bit is set.
    ///               
    ///               4. <c>...</c> grab the full ranges from as many dimensions as needed to
    ///               fully specify a slice for every dimension of the input shape.
    ///               
    ///               5. <c>:-3:-1</c> shows the use of negative indices. A negative index <c>i</c> associated
    ///               with a dimension that has shape <c>s</c> is converted to a positive index
    ///               <c>s + i</c>. So <c>-1</c> becomes <c>s-1</c> (i.e. the last element). This conversion
    ///               is done internally so begin, end and strides receive x, -3, and -1.
    ///               The appropriate begin_mask bit is set to indicate the start range is the
    ///               full range (ignoring the x).
    ///               
    ///               6. <c>:</c> indicates that the entire contents of the corresponding dimension
    ///               is selected. This is equivalent to <c>::</c> or <c>0::1</c>. begin, end, and strides
    ///               receive 0, 0, and 1, respectively. The appropriate bits in <c>begin_mask</c> and
    ///               <c>end_mask</c> are also set.
    ///               
    ///               *Requirements*:
    ///               <c>0 != strides[i] for i in [0, m)</c><c>ellipsis_mask must be a power of two (only one ellipsis)</c></remarks>
    member this.StridedSlice(input : TF, ``begin`` : TF, ``end`` : TF, strides : TF, ?begin_mask : Int64, ?end_mask : Int64, ?ellipsis_mask : Int64, ?new_axis_mask : Int64, ?shrink_axis_mask : Int64, ?operName : String) =
        let begin_mask = defaultArg (begin_mask |> Option.map Nullable) (Nullable())
        let end_mask = defaultArg (end_mask |> Option.map Nullable) (Nullable())
        let ellipsis_mask = defaultArg (ellipsis_mask |> Option.map Nullable) (Nullable())
        let new_axis_mask = defaultArg (new_axis_mask |> Option.map Nullable) (Nullable())
        let shrink_axis_mask = defaultArg (shrink_axis_mask |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StridedSlice(input.TFOutput, ``begin``.TFOutput, ``end``.TFOutput, strides.TFOutput, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask, operName))
    member this.StridedSliceAssign(reference : TF, ``begin`` : TF, ``end`` : TF, strides : TF, value : TF, ?begin_mask : Int64, ?end_mask : Int64, ?ellipsis_mask : Int64, ?new_axis_mask : Int64, ?shrink_axis_mask : Int64, ?operName : String) =
        let begin_mask = defaultArg (begin_mask |> Option.map Nullable) (Nullable())
        let end_mask = defaultArg (end_mask |> Option.map Nullable) (Nullable())
        let ellipsis_mask = defaultArg (ellipsis_mask |> Option.map Nullable) (Nullable())
        let new_axis_mask = defaultArg (new_axis_mask |> Option.map Nullable) (Nullable())
        let shrink_axis_mask = defaultArg (shrink_axis_mask |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StridedSliceAssign(reference.TFOutput, ``begin``.TFOutput, ``end``.TFOutput, strides.TFOutput, value.TFOutput, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask, operName))
    /// <summary>
    ///               Returns the gradient of <c>StridedSlice</c>.
    ///             </summary><param name="shape"></param><param name="begin"></param><param name="end"></param><param name="strides"></param><param name="dy"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StridedSliceGrad'.
    ///             </param><param name="begin_mask">
    ///               Optional argument
    ///             </param><param name="end_mask">
    ///               Optional argument
    ///             </param><param name="ellipsis_mask">
    ///               Optional argument
    ///             </param><param name="new_axis_mask">
    ///               Optional argument
    ///             </param><param name="shrink_axis_mask">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Since <c>StridedSlice</c> cuts out pieces of its <c>input</c> which is size
    ///               <c>shape</c>, its gradient will have the same shape (which is passed here
    ///               as <c>shape</c>). The gradient will be zero in any element that the slice
    ///               does not select.
    ///               
    ///               Arguments are the same as StridedSliceGrad with the exception that
    ///               <c>dy</c> is the input gradient to be propagated and <c>shape</c> is the
    ///               shape of <c>StridedSlice</c>'s <c>input</c>.
    ///             </remarks>
    member this.StridedSliceGrad(shape : TF, ``begin`` : TF, ``end`` : TF, strides : TF, dy : TF, ?begin_mask : Int64, ?end_mask : Int64, ?ellipsis_mask : Int64, ?new_axis_mask : Int64, ?shrink_axis_mask : Int64, ?operName : String) =
        let begin_mask = defaultArg (begin_mask |> Option.map Nullable) (Nullable())
        let end_mask = defaultArg (end_mask |> Option.map Nullable) (Nullable())
        let ellipsis_mask = defaultArg (ellipsis_mask |> Option.map Nullable) (Nullable())
        let new_axis_mask = defaultArg (new_axis_mask |> Option.map Nullable) (Nullable())
        let shrink_axis_mask = defaultArg (shrink_axis_mask |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StridedSliceGrad(shape.TFOutput, ``begin``.TFOutput, ``end``.TFOutput, strides.TFOutput, dy.TFOutput, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask, operName))
    /// <summary>
    ///               Formats a string template using a list of tensors.
    ///             </summary><param name="inputs">
    ///               The list of tensors to format into the placeholder string.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringFormat'.
    ///             </param><param name="template">
    ///               Optional argument
    ///               A string, the template to format tensor summaries into.
    ///             </param><param name="placeholder">
    ///               Optional argument
    ///               A string, at each placeholder in the template a subsequent tensor summary will be inserted.
    ///             </param><param name="summarize">
    ///               Optional argument
    ///               When formatting the tensor summaries print the first and last summarize entries of each tensor dimension.
    ///             </param><returns>
    ///               = The resulting string scalar.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Formats a string template using a list of tensors, pretty-printing tensor summaries.
    ///             </remarks>
    member this.StringFormat(inputs : TF[], ?template : String, ?placeholder : String, ?summarize : Int64, ?operName : String) =
        let template = defaultArg template null
        let placeholder = defaultArg placeholder null
        let summarize = defaultArg (summarize |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringFormat(inputs |> Array.map (fun x -> x.TFOutput), template, placeholder, summarize, operName))
    /// <summary>
    ///               Joins the strings in the given list of string tensors into one tensor;
    ///             </summary><param name="inputs">
    ///               A list of string tensors.  The tensors must all have the same shape,
    ///               or be scalars.  Scalars may be mixed in; these will be broadcast to the shape
    ///               of non-scalar inputs.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringJoin'.
    ///             </param><param name="separator">
    ///               Optional argument
    ///               string, an optional join separator.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               with the given separator (default is an empty separator).
    ///             </remarks>
    member this.StringJoin(inputs : TF[], ?separator : String, ?operName : String) =
        let separator = defaultArg separator null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringJoin(inputs |> Array.map (fun x -> x.TFOutput), separator, operName))
    /// <summary>
    ///               String lengths of <c>input</c>.
    ///             </summary><param name="input">
    ///               The string for which to compute the length.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringLength'.
    ///             </param><param name="unit">
    ///               Optional argument
    ///               The unit that is counted to compute string length.  One of: <c>"BYTE"</c> (for
    ///               the number of bytes in each string) or <c>"UTF8_CHAR"</c> (for the number of UTF-8
    ///               encoded Unicode code points in each string).  Results are undefined
    ///               if <c>unit=UTF8_CHAR</c> and the <c>input</c> strings do not contain structurally
    ///               valid UTF-8.
    ///             </param><returns>
    ///               Integer tensor that has the same shape as <c>input</c>. The output contains the
    ///               element-wise string lengths of <c>input</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Computes the length of each string given in the input tensor.
    ///             </remarks>
    member this.StringLength(input : TF, ?unit : String, ?operName : String) =
        let unit = defaultArg unit null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringLength(input.TFOutput, unit, operName))
    /// <summary>
    ///               Split elements of <c>input</c> based on <c>delimiter</c> into a <c>SparseTensor</c>.
    ///             </summary><param name="input">
    ///               1-D. Strings to split.
    ///             </param><param name="delimiter">
    ///               0-D. Delimiter characters (bytes), or empty string.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringSplit'.
    ///             </param><param name="skip_empty">
    ///               Optional argument
    ///               A <c>bool</c>. If <c>True</c>, skip the empty strings from the result.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               indices: A dense matrix of int64 representing the indices of the sparse tensor.
    ///               values: A vector of strings corresponding to the splited values.
    ///               shape: a length-2 vector of int64 representing the shape of the sparse
    ///               tensor, where the first value is N and the second value is the maximum number
    ///               of tokens in a single input entry.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Let N be the size of source (typically N will be the batch size). Split each
    ///               element of <c>input</c> based on <c>delimiter</c> and return a <c>SparseTensor</c>
    ///               containing the splitted tokens. Empty tokens are ignored.
    ///               
    ///               <c>delimiter</c> can be empty, or a string of split characters. If <c>delimiter</c> is an
    ///               empty string, each element of <c>input</c> is split into individual single-byte
    ///               character strings, including splitting of UTF-8 multibyte sequences. Otherwise
    ///               every character of <c>delimiter</c> is a potential split point.
    ///               
    ///               For example:
    ///               N = 2, input[0] is 'hello world' and input[1] is 'a b c', then the output
    ///               will be
    ///               
    ///               indices = [0, 0;
    ///               0, 1;
    ///               1, 0;
    ///               1, 1;
    ///               1, 2]
    ///               shape = [2, 3]
    ///               values = ['hello', 'world', 'a', 'b', 'c']
    ///             </remarks>
    member this.StringSplit(input : TF, delimiter : TF, ?skip_empty : Boolean, ?operName : String) =
        let skip_empty = defaultArg (skip_empty |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.StringSplit(input.TFOutput, delimiter.TFOutput, skip_empty, operName)
    /// <summary>
    ///               Split elements of <c>source</c> based on <c>sep</c> into a <c>SparseTensor</c>.
    ///             </summary><param name="input"><c>1-D</c> string <c>Tensor</c>, the strings to split.
    ///             </param><param name="sep"><c>0-D</c> string <c>Tensor</c>, the delimiter character.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringSplitV2'.
    ///             </param><param name="maxsplit">
    ///               Optional argument
    ///               An <c>int</c>. If <c>maxsplit &amp;gt; 0</c>, limit of the split of the result.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               indices:
    ///               values:
    ///               shape:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Let N be the size of source (typically N will be the batch size). Split each
    ///               element of <c>source</c> based on <c>sep</c> and return a <c>SparseTensor</c>
    ///               containing the split tokens. Empty tokens are ignored.
    ///               
    ///               For example, N = 2, source[0] is 'hello world' and source[1] is 'a b c',
    ///               then the output will be
    ///                <code>
    ///               st.indices = [0, 0;
    ///               0, 1;
    ///               1, 0;
    ///               1, 1;
    ///               1, 2]
    ///               st.shape = [2, 3]
    ///               st.values = ['hello', 'world', 'a', 'b', 'c']
    ///                </code>
    ///               
    ///               If <c>sep</c> is given, consecutive delimiters are not grouped together and are
    ///               deemed to delimit empty strings. For example, source of <c>"1&amp;lt;&amp;gt;2&amp;lt;&amp;gt;&amp;lt;&amp;gt;3"</c> and
    ///               sep of <c>"&amp;lt;&amp;gt;"</c> returns <c>["1", "2", "", "3"]</c>. If <c>sep</c> is None or an empty
    ///               string, consecutive whitespace are regarded as a single separator, and the
    ///               result will contain no empty strings at the startor end if the string has
    ///               leading or trailing whitespace.
    ///               
    ///               Note that the above mentioned behavior matches python's str.split.
    ///             </remarks>
    member this.StringSplitV2(input : TF, sep : TF, ?maxsplit : Int64, ?operName : String) =
        let maxsplit = defaultArg (maxsplit |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.StringSplitV2(input.TFOutput, sep.TFOutput, maxsplit, operName)
    /// <summary>
    ///               Strip leading and trailing whitespaces from the Tensor.
    ///             </summary><param name="input">
    ///               A string <c>Tensor</c> of any shape.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringStrip'.
    ///             </param><returns>
    ///               A string <c>Tensor</c> of the same shape as the input.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.StringStrip(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringStrip(input.TFOutput, operName))
    /// <summary>
    ///               Converts each string in the input Tensor to its hash mod by a number of buckets.
    ///             </summary><param name="string_tensor"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringToHashBucket'.
    ///             </param><param name="num_buckets">
    ///               The number of buckets.
    ///             </param><returns>
    ///               A Tensor of the same shape as the input <c>string_tensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The hash function is deterministic on the content of the string within the
    ///               process.
    ///               
    ///               Note that the hash function may change from time to time.
    ///               This functionality will be deprecated and it's recommended to use
    ///               <c>tf.string_to_hash_bucket_fast()</c> or <c>tf.string_to_hash_bucket_strong()</c>.
    ///             </remarks>
    member this.StringToHashBucket(string_tensor : TF, num_buckets : Int64, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringToHashBucket(string_tensor.TFOutput, num_buckets, operName))
    /// <summary>
    ///               Converts each string in the input Tensor to its hash mod by a number of buckets.
    ///             </summary><param name="input">
    ///               The strings to assign a hash bucket.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringToHashBucketFast'.
    ///             </param><param name="num_buckets">
    ///               The number of buckets.
    ///             </param><returns>
    ///               A Tensor of the same shape as the input <c>string_tensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The hash function is deterministic on the content of the string within the
    ///               process and will never change. However, it is not suitable for cryptography.
    ///               This function may be used when CPU time is scarce and inputs are trusted or
    ///               unimportant. There is a risk of adversaries constructing inputs that all hash
    ///               to the same bucket. To prevent this problem, use a strong hash function with
    ///               <c>tf.string_to_hash_bucket_strong</c>.
    ///             </remarks>
    member this.StringToHashBucketFast(input : TF, num_buckets : Int64, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringToHashBucketFast(input.TFOutput, num_buckets, operName))
    /// <summary>
    ///               Converts each string in the input Tensor to its hash mod by a number of buckets.
    ///             </summary><param name="input">
    ///               The strings to assign a hash bucket.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringToHashBucketStrong'.
    ///             </param><param name="num_buckets">
    ///               The number of buckets.
    ///             </param><param name="key">
    ///               The key for the keyed hash function passed as a list of two uint64
    ///               elements.
    ///             </param><returns>
    ///               A Tensor of the same shape as the input <c>string_tensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The hash function is deterministic on the content of the string within the
    ///               process. The hash function is a keyed hash function, where attribute <c>key</c>
    ///               defines the key of the hash function. <c>key</c> is an array of 2 elements.
    ///               
    ///               A strong hash is important when inputs may be malicious, e.g. URLs with
    ///               additional components. Adversaries could try to make their inputs hash to the
    ///               same bucket for a denial-of-service attack or to skew the results. A strong
    ///               hash prevents this by making it difficult, if not infeasible, to compute inputs
    ///               that hash to the same bucket. This comes at a cost of roughly 4x higher compute
    ///               time than <c>tf.string_to_hash_bucket_fast</c>.
    ///             </remarks>
    member this.StringToHashBucketStrong(input : TF, num_buckets : Int64, key : Int64[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringToHashBucketStrong(input.TFOutput, num_buckets, key, operName))
    /// <summary>
    ///               Converts each string in the input Tensor to the specified numeric type.
    ///             </summary><param name="string_tensor"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'StringToNumber'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///               The numeric type to interpret each string in <c>string_tensor</c> as.
    ///             </param><returns>
    ///               A Tensor of the same shape as the input <c>string_tensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               (Note that int32 overflow results in an error while float overflow
    ///               results in a rounded value.)
    ///             </remarks>
    member this.StringToNumber(string_tensor : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.StringToNumber(string_tensor.TFOutput, out_type, operName))
    /// <summary>
    ///               Returns x - y element-wise.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sub'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               *NOTE*: <c>Subtract</c> supports broadcasting. More about broadcasting
    ///               [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///             </remarks>
    member this.Sub(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sub(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Computes the sum of elements across dimensions of a tensor.
    ///             </summary><param name="input">
    ///               The tensor to reduce.
    ///             </param><param name="reduction_indices">
    ///               The dimensions to reduce. Must be in the range
    ///               <c>[-rank(input), rank(input))</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sum'.
    ///             </param><param name="keep_dims">
    ///               Optional argument
    ///               If true, retain reduced dimensions with length 1.
    ///             </param><returns>
    ///               The reduced tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Reduces <c>input</c> along the dimensions given in <c>axis</c>. Unless
    ///               <c>keep_dims</c> is true, the rank of the tensor is reduced by 1 for each entry in
    ///               <c>axis</c>. If <c>keep_dims</c> is true, the reduced dimensions are
    ///               retained with length 1.
    ///             </remarks>
    member this.Sum(input : TF, reduction_indices : TF, ?keep_dims : Boolean, ?operName : String) =
        let keep_dims = defaultArg (keep_dims |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sum(input.TFOutput, reduction_indices.TFOutput, keep_dims, operName))
    /// <summary>
    ///               Computes the singular value decompositions of one or more matrices.
    ///             </summary><param name="input">
    ///               A tensor of shape <c>[..., M, N]</c> whose inner-most 2 dimensions
    ///               form matrices of size <c>[M, N]</c>. Let <c>P</c> be the minimum of <c>M</c> and <c>N</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Svd'.
    ///             </param><param name="compute_uv">
    ///               Optional argument
    ///               If true, left and right singular vectors will be
    ///               computed and returned in <c>u</c> and <c>v</c>, respectively.
    ///               If false, <c>u</c> and <c>v</c> are not set and should never referenced.
    ///             </param><param name="full_matrices">
    ///               Optional argument
    ///               If true, compute full-sized <c>u</c> and <c>v</c>. If false
    ///               (the default), compute only the leading <c>P</c> singular vectors.
    ///               Ignored if <c>compute_uv</c> is <c>False</c>.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               s: Singular values. Shape is <c>[..., P]</c>.
    ///               u: Left singular vectors. If <c>full_matrices</c> is <c>False</c> then shape is
    ///               <c>[..., M, P]</c>; if <c>full_matrices</c> is <c>True</c> then shape is
    ///               <c>[..., M, M]</c>. Undefined if <c>compute_uv</c> is <c>False</c>.
    ///               v: Left singular vectors. If <c>full_matrices</c> is <c>False</c> then shape is
    ///               <c>[..., N, P]</c>. If <c>full_matrices</c> is <c>True</c> then shape is <c>[..., N, N]</c>.
    ///               Undefined if <c>compute_uv</c> is false.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Computes the SVD of each inner matrix in <c>input</c> such that
    ///               <c>input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])</c><code>
    ///               # a is a tensor containing a batch of matrices.
    ///               # s is a tensor of singular values for each matrix.
    ///               # u is the tensor containing of left singular vectors for each matrix.
    ///               # v is the tensor containing of right singular vectors for each matrix.
    ///               s, u, v = svd(a)
    ///               s, _, _ = svd(a, compute_uv=False)
    ///                </code></remarks>
    member this.Svd(input : TF, ?compute_uv : Boolean, ?full_matrices : Boolean, ?operName : String) =
        let compute_uv = defaultArg (compute_uv |> Option.map Nullable) (Nullable())
        let full_matrices = defaultArg (full_matrices |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.Svd(input.TFOutput, compute_uv, full_matrices, operName)
    /// <summary>
    ///               Forwards <c>data</c> to the output port determined by <c>pred</c>.
    ///             </summary><param name="data">
    ///               The tensor to be forwarded to the appropriate output.
    ///             </param><param name="pred">
    ///               A scalar that specifies which output port will receive data.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Switch'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_false: If <c>pred</c> is false, data will be forwarded to this output.
    ///               output_true: If <c>pred</c> is true, data will be forwarded to this output.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               If <c>pred</c> is true, the <c>data</c> input is forwarded to <c>output_true</c>. Otherwise,
    ///               the data goes to <c>output_false</c>.
    ///               
    ///               See also <c>RefSwitch</c> and <c>Merge</c>.
    ///             </remarks>
    member this.Switch(data : TF, pred : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.Switch(data.TFOutput, pred.TFOutput, operName)
    /// <summary>
    ///               Creates a dataset that contains <c>count</c> elements from the <c>input_dataset</c>.
    ///             </summary><param name="input_dataset"></param><param name="count">
    ///               A scalar representing the number of elements from the <c>input_dataset</c>
    ///               that should be taken. A value of <c>-1</c> indicates that all of <c>input_dataset</c>
    ///               is taken.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TakeDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TakeDataset(input_dataset : TF, count : TF, output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TakeDataset(input_dataset.TFOutput, count.TFOutput, output_types, output_shapes, operName))
    /// <summary>
    ///               Read <c>SparseTensors</c> from a <c>SparseTensorsMap</c> and concatenate them.
    ///             </summary><param name="sparse_handles">
    ///               1-D, The <c>N</c> serialized <c>SparseTensor</c> objects.
    ///               Shape: <c>[N]</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TakeManySparseFromTensorsMap'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               The container name for the <c>SparseTensorsMap</c> read by this op.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               The shared name for the <c>SparseTensorsMap</c> read by this op.
    ///               It should not be blank; rather the <c>shared_name</c> or unique Operation name
    ///               of the Op that created the original <c>SparseTensorsMap</c> should be used.
    ///             </param><param name="dtype">
    ///               The <c>dtype</c> of the <c>SparseTensor</c> objects stored in the
    ///               <c>SparseTensorsMap</c>.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               sparse_indices: 2-D.  The <c>indices</c> of the minibatch <c>SparseTensor</c>.
    ///               sparse_values: 1-D.  The <c>values</c> of the minibatch <c>SparseTensor</c>.
    ///               sparse_shape: 1-D.  The <c>shape</c> of the minibatch <c>SparseTensor</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The input <c>sparse_handles</c> must be an <c>int64</c> matrix of shape <c>[N, 1]</c> where
    ///               <c>N</c> is the minibatch size and the rows correspond to the output handles of
    ///               <c>AddSparseToTensorsMap</c> or <c>AddManySparseToTensorsMap</c>.  The ranks of the
    ///               original <c>SparseTensor</c> objects that went into the given input ops must all
    ///               match.  When the final <c>SparseTensor</c> is created, it has rank one
    ///               higher than the ranks of the incoming <c>SparseTensor</c> objects
    ///               (they have been concatenated along a new row dimension on the left).
    ///               
    ///               The output <c>SparseTensor</c> object's shape values for all dimensions but the
    ///               first are the max across the input <c>SparseTensor</c> objects' shape values
    ///               for the corresponding dimensions.  Its first shape value is <c>N</c>, the minibatch
    ///               size.
    ///               
    ///               The input <c>SparseTensor</c> objects' indices are assumed ordered in
    ///               standard lexicographic order.  If this is not the case, after this
    ///               step run <c>SparseReorder</c> to restore index ordering.
    ///               
    ///               For example, if the handles represent an input, which is a <c>[2, 3]</c> matrix
    ///               representing two original <c>SparseTensor</c> objects:
    ///               
    ///                <code>
    ///               index = [ 0]
    ///               [10]
    ///               [20]
    ///               values = [1, 2, 3]
    ///               shape = [50]
    ///                </code>
    ///               
    ///               and
    ///               
    ///                <code>
    ///               index = [ 2]
    ///               [10]
    ///               values = [4, 5]
    ///               shape = [30]
    ///                </code>
    ///               
    ///               then the final <c>SparseTensor</c> will be:
    ///               
    ///                <code>
    ///               index = [0  0]
    ///               [0 10]
    ///               [0 20]
    ///               [1  2]
    ///               [1 10]
    ///               values = [1, 2, 3, 4, 5]
    ///               shape = [2 50]
    ///                </code></remarks>
    member this.TakeManySparseFromTensorsMap(sparse_handles : TF, dtype : TFDataType, ?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.TakeManySparseFromTensorsMap(sparse_handles.TFOutput, dtype, container, shared_name, operName)
    /// <summary>
    ///               Computes tan of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Tan'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Tan(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Tan(x.TFOutput, operName))
    /// <summary>
    ///               Computes hyperbolic tangent of <c>x</c> element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Tanh'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Tanh(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Tanh(x.TFOutput, operName))
    /// <summary>
    ///               Computes the gradient for the tanh of <c>x</c> wrt its input.
    ///             </summary><param name="y"></param><param name="dy"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TanhGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Specifically, <c>grad = dy * (1 - y*y)</c>, where <c>y = tanh(x)</c>, and <c>dy</c>
    ///               is the corresponding input gradient.
    ///             </remarks>
    member this.TanhGrad(y : TF, dy : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TanhGrad(y.TFOutput, dy.TFOutput, operName))
    /// <summary>
    ///               Returns a tensor that may be mutated, but only persists within a single step.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TemporaryVariable'.
    ///             </param><param name="var_name">
    ///               Optional argument
    ///               Overrides the name used for the temporary variable resource. Default
    ///               value is the name of the 'TemporaryVariable' op (which is guaranteed unique).
    ///             </param><param name="shape">
    ///               The shape of the variable tensor.
    ///             </param><param name="dtype">
    ///               The type of elements in the variable tensor.
    ///             </param><returns>
    ///               A reference to the variable tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This is an experimental op for internal use only and it is possible to use this
    ///               op in unsafe ways.  DO NOT USE unless you fully understand the risks.
    ///               
    ///               It is the caller's responsibility to ensure that 'ref' is eventually passed to a
    ///               matching 'DestroyTemporaryVariable' op after all other uses have completed.
    ///               
    ///               Outputs a ref to the tensor state so it may be read or modified.
    ///               
    ///               E.g.
    ///               var = state_ops._temporary_variable([1, 2], types.float_)
    ///               var_name = var.op.name
    ///               var = state_ops.assign(var, [[4.0, 5.0]])
    ///               var = state_ops.assign_add(var, [[6.0, 7.0]])
    ///               final = state_ops._destroy_temporary_variable(var, var_name=var_name)
    ///             </remarks>
    member this.TemporaryVariable(shape : TFShape, dtype : TFDataType, ?var_name : String, ?operName : String) =
        let var_name = defaultArg var_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TemporaryVariable(shape, dtype, var_name, operName))
    /// <summary>
    ///               Deprecated. Use TensorArrayCloseV3
    ///             </summary><param name="handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayCloseV2'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.TensorArrayCloseV2(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayCloseV2(handle.TFOutput, operName)
    /// <summary>
    ///               Delete the TensorArray from its resource container.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayCloseV3'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This enables the user to close and release the resource in the middle
    ///               of a step/run.
    ///             </remarks>
    member this.TensorArrayCloseV3(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayCloseV3(handle.TFOutput, operName)
    /// <summary>
    ///               Deprecated. Use TensorArrayConcatV3
    ///             </summary><param name="handle"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayConcatV2'.
    ///             </param><param name="element_shape_except0">
    ///               Optional argument
    ///             </param><param name="dtype"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               value:
    ///               lengths:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.TensorArrayConcatV2(handle : TF, flow_in : TF, dtype : TFDataType, ?element_shape_except0 : TFShape, ?operName : String) =
        let element_shape_except0 = defaultArg element_shape_except0 null
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayConcatV2(handle.TFOutput, flow_in.TFOutput, dtype, element_shape_except0, operName)
    /// <summary>
    ///               Concat the elements from the TensorArray into value <c>value</c>.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray.
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayConcatV3'.
    ///             </param><param name="element_shape_except0">
    ///               Optional argument
    ///               The expected shape of an element, if known,
    ///               excluding the first dimension. Used to validate the shapes of
    ///               TensorArray elements. If this shape is not fully specified, concatenating
    ///               zero-size TensorArrays is an error.
    ///             </param><param name="dtype">
    ///               The type of the elem that is returned.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               value: All of the elements in the TensorArray, concatenated along the first
    ///               axis.
    ///               lengths: A vector of the row sizes of the original T elements in the
    ///               value output.  In the example above, this would be the values:
    ///               <c>(n1, n2, ..., n(T-1))</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Takes <c>T</c> elements of shapes
    ///               
    ///                <code>
    ///               (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
    ///                </code>
    ///               
    ///               and concatenates them into a Tensor of shape:
    ///               
    ///                <code>
    ///                (n0 + n1 + ... + n(T-1) x d0 x d1 x ...)
    ///                </code>
    ///               
    ///               All elements must have the same shape (excepting the first dimension).
    ///             </remarks>
    member this.TensorArrayConcatV3(handle : TF, flow_in : TF, dtype : TFDataType, ?element_shape_except0 : TFShape, ?operName : String) =
        let element_shape_except0 = defaultArg element_shape_except0 null
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayConcatV3(handle.TFOutput, flow_in.TFOutput, dtype, element_shape_except0, operName)
    /// <summary>
    ///               Deprecated. Use TensorArrayGatherV3
    ///             </summary><param name="handle"></param><param name="indices"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayGatherV2'.
    ///             </param><param name="element_shape">
    ///               Optional argument
    ///             </param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayGatherV2(handle : TF, indices : TF, flow_in : TF, dtype : TFDataType, ?element_shape : TFShape, ?operName : String) =
        let element_shape = defaultArg element_shape null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayGatherV2(handle.TFOutput, indices.TFOutput, flow_in.TFOutput, dtype, element_shape, operName))
    /// <summary>
    ///               Gather specific elements from the TensorArray into output <c>value</c>.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray.
    ///             </param><param name="indices">
    ///               The locations in the TensorArray from which to read tensor elements.
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayGatherV3'.
    ///             </param><param name="element_shape">
    ///               Optional argument
    ///               The expected shape of an element, if known. Used to
    ///               validate the shapes of TensorArray elements. If this shape is not
    ///               fully specified, gathering zero-size TensorArrays is an error.
    ///             </param><param name="dtype">
    ///               The type of the elem that is returned.
    ///             </param><returns>
    ///               All of the elements in the TensorArray, concatenated along a new
    ///               axis (the new dimension 0).
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               All elements selected by <c>indices</c> must have the same shape.
    ///             </remarks>
    member this.TensorArrayGatherV3(handle : TF, indices : TF, flow_in : TF, dtype : TFDataType, ?element_shape : TFShape, ?operName : String) =
        let element_shape = defaultArg element_shape null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayGatherV3(handle.TFOutput, indices.TFOutput, flow_in.TFOutput, dtype, element_shape, operName))
    /// <summary>
    ///               Deprecated. Use TensorArrayGradV3
    ///             </summary><param name="handle"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayGradV2'.
    ///             </param><param name="source"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayGradV2(handle : TF, flow_in : TF, source : String, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayGradV2(handle.TFOutput, flow_in.TFOutput, source, operName))
    /// <summary>
    ///               Creates a TensorArray for storing the gradients of values in the given handle.
    ///             </summary><param name="handle">
    ///               The handle to the forward TensorArray.
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayGradV3'.
    ///             </param><param name="source">
    ///               The gradient source string, used to decide which gradient TensorArray
    ///               to return.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               grad_handle:
    ///               flow_out:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               If the given TensorArray gradient already exists, returns a reference to it.
    ///               
    ///               Locks the size of the original TensorArray by disabling its dynamic size flag.
    ///               
    ///               **A note about the input flow_in:**
    ///               
    ///               The handle flow_in forces the execution of the gradient lookup to occur
    ///               only after certain other operations have occurred.  For example, when
    ///               the forward TensorArray is dynamically sized, writes to this TensorArray
    ///               may resize the object.  The gradient TensorArray is statically sized based
    ///               on the size of the forward TensorArray when this operation executes.
    ///               Furthermore, the size of the forward TensorArray is frozen by this call.
    ///               As a result, the flow is used to ensure that the call to generate the gradient
    ///               TensorArray only happens after all writes are executed.
    ///               
    ///               In the case of dynamically sized TensorArrays, gradient computation should
    ///               only be performed on read operations that have themselves been chained via
    ///               flow to occur only after all writes have executed. That way the final size
    ///               of the forward TensorArray is known when this operation is called.
    ///               
    ///               **A note about the source attribute:**
    ///               
    ///               TensorArray gradient calls use an accumulator TensorArray object.  If
    ///               multiple gradients are calculated and run in the same session, the multiple
    ///               gradient nodes may accidentally flow through the same accumulator TensorArray.
    ///               This double counts and generally breaks the TensorArray gradient flow.
    ///               
    ///               The solution is to identify which gradient call this particular
    ///               TensorArray gradient is being called in.  This is performed by identifying
    ///               a unique string (e.g. "gradients", "gradients_1", ...) from the input
    ///               gradient Tensor's name.  This string is used as a suffix when creating
    ///               the TensorArray gradient object here (the attribute <c>source</c>).
    ///               
    ///               The attribute <c>source</c> is added as a suffix to the forward TensorArray's
    ///               name when performing the creation / lookup, so that each separate gradient
    ///               calculation gets its own TensorArray accumulator.
    ///             </remarks>
    member this.TensorArrayGradV3(handle : TF, flow_in : TF, source : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayGradV3(handle.TFOutput, flow_in.TFOutput, source, operName)
    /// <summary>
    ///               Creates a TensorArray for storing multiple gradients of values in the given handle.
    ///             </summary><param name="handle">
    ///               The handle to the forward TensorArray.
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="shape_to_prepend">
    ///               An int32 vector representing a shape. Elements in the gradient accumulator will
    ///               have shape which is this shape_to_prepend value concatenated with shape of the
    ///               elements in the TensorArray corresponding to the input handle.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayGradWithShape'.
    ///             </param><param name="source">
    ///               The gradient source string, used to decide which gradient TensorArray
    ///               to return.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               grad_handle:
    ///               flow_out:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Similar to TensorArrayGradV3. However it creates an accumulator with an
    ///               expanded shape compared to the input TensorArray whose gradient is being
    ///               computed. This enables multiple gradients for the same TensorArray to be
    ///               calculated using the same accumulator.
    ///             </remarks>
    member this.TensorArrayGradWithShape(handle : TF, flow_in : TF, shape_to_prepend : TF, source : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayGradWithShape(handle.TFOutput, flow_in.TFOutput, shape_to_prepend.TFOutput, source, operName)
    /// <summary>
    ///               Deprecated. Use TensorArrayReadV3
    ///             </summary><param name="handle"></param><param name="index"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayReadV2'.
    ///             </param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayReadV2(handle : TF, index : TF, flow_in : TF, dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayReadV2(handle.TFOutput, index.TFOutput, flow_in.TFOutput, dtype, operName))
    /// <summary>
    ///               Read an element from the TensorArray into output <c>value</c>.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray.
    ///             </param><param name="index"></param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayReadV3'.
    ///             </param><param name="dtype">
    ///               The type of the elem that is returned.
    ///             </param><returns>
    ///               The tensor that is read from the TensorArray.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayReadV3(handle : TF, index : TF, flow_in : TF, dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayReadV3(handle.TFOutput, index.TFOutput, flow_in.TFOutput, dtype, operName))
    /// <summary>
    ///               Deprecated. Use TensorArrayScatterV3
    ///             </summary><param name="handle"></param><param name="indices"></param><param name="value"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayScatterV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayScatterV2(handle : TF, indices : TF, value : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayScatterV2(handle.TFOutput, indices.TFOutput, value.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Scatter the data from the input value into specific TensorArray elements.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray.
    ///             </param><param name="indices">
    ///               The locations at which to write the tensor elements.
    ///             </param><param name="value">
    ///               The concatenated tensor to write to the TensorArray.
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayScatterV3'.
    ///             </param><returns>
    ///               A float scalar that enforces proper chaining of operations.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks><c>indices</c> must be a vector, its length must match the first dim of <c>value</c>.
    ///             </remarks>
    member this.TensorArrayScatterV3(handle : TF, indices : TF, value : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayScatterV3(handle.TFOutput, indices.TFOutput, value.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Deprecated. Use TensorArraySizeV3
    ///             </summary><param name="handle"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArraySizeV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArraySizeV2(handle : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArraySizeV2(handle.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Get the current size of the TensorArray.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArraySizeV3'.
    ///             </param><returns>
    ///               The current size of the TensorArray.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArraySizeV3(handle : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArraySizeV3(handle.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Deprecated. Use TensorArraySplitV3
    ///             </summary><param name="handle"></param><param name="value"></param><param name="lengths"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArraySplitV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArraySplitV2(handle : TF, value : TF, lengths : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArraySplitV2(handle.TFOutput, value.TFOutput, lengths.TFOutput, flow_in.TFOutput, operName))
    member this.TensorArraySplitV3(handle : TF, value : TF, lengths : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArraySplitV3(handle.TFOutput, value.TFOutput, lengths.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Deprecated. Use TensorArrayV3
    ///             </summary><param name="size"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayV2'.
    ///             </param><param name="element_shape">
    ///               Optional argument
    ///             </param><param name="dynamic_size">
    ///               Optional argument
    ///             </param><param name="clear_after_read">
    ///               Optional argument
    ///             </param><param name="tensor_array_name">
    ///               Optional argument
    ///             </param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayV2(size : TF, dtype : TFDataType, ?element_shape : TFShape, ?dynamic_size : Boolean, ?clear_after_read : Boolean, ?tensor_array_name : String, ?operName : String) =
        let element_shape = defaultArg element_shape null
        let dynamic_size = defaultArg (dynamic_size |> Option.map Nullable) (Nullable())
        let clear_after_read = defaultArg (clear_after_read |> Option.map Nullable) (Nullable())
        let tensor_array_name = defaultArg tensor_array_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayV2(size.TFOutput, dtype, element_shape, dynamic_size, clear_after_read, tensor_array_name, operName))
    /// <summary>
    ///               An array of Tensors of given size.
    ///             </summary><param name="size">
    ///               The size of the array.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayV3'.
    ///             </param><param name="element_shape">
    ///               Optional argument
    ///               The expected shape of an element, if known. Used to
    ///               validate the shapes of TensorArray elements. If this shape is not
    ///               fully specified, gathering zero-size TensorArrays is an error.
    ///             </param><param name="dynamic_size">
    ///               Optional argument
    ///               A boolean that determines whether writes to the TensorArray
    ///               are allowed to grow the size.  By default, this is not allowed.
    ///             </param><param name="clear_after_read">
    ///               Optional argument
    ///               If true (default), Tensors in the TensorArray are cleared
    ///               after being read.  This disables multiple read semantics but allows early
    ///               release of memory.
    ///             </param><param name="identical_element_shapes">
    ///               Optional argument
    ///               If true (default is false), then all
    ///               elements in the TensorArray will be expected to have have identical shapes.
    ///               This allows certain behaviors, like dynamically checking for
    ///               consistent shapes on write, and being able to fill in properly
    ///               shaped zero tensors on stack -- even if the element_shape attribute
    ///               is not fully defined.
    ///             </param><param name="tensor_array_name">
    ///               Optional argument
    ///               Overrides the name used for the temporary tensor_array
    ///               resource. Default value is the name of the 'TensorArray' op (which
    ///               is guaranteed unique).
    ///             </param><param name="dtype">
    ///               The type of the elements on the tensor_array.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               handle: The handle to the TensorArray.
    ///               flow: A scalar used to control gradient flow.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Write data via Write and read via Read or Pack.
    ///             </remarks>
    member this.TensorArrayV3(size : TF, dtype : TFDataType, ?element_shape : TFShape, ?dynamic_size : Boolean, ?clear_after_read : Boolean, ?identical_element_shapes : Boolean, ?tensor_array_name : String, ?operName : String) =
        let element_shape = defaultArg element_shape null
        let dynamic_size = defaultArg (dynamic_size |> Option.map Nullable) (Nullable())
        let clear_after_read = defaultArg (clear_after_read |> Option.map Nullable) (Nullable())
        let identical_element_shapes = defaultArg (identical_element_shapes |> Option.map Nullable) (Nullable())
        let tensor_array_name = defaultArg tensor_array_name null
        let operName = defaultArg operName null
        this.TFGraph.TensorArrayV3(size.TFOutput, dtype, element_shape, dynamic_size, clear_after_read, identical_element_shapes, tensor_array_name, operName)
    /// <summary>
    ///               Deprecated. Use TensorArrayGradV3
    ///             </summary><param name="handle"></param><param name="index"></param><param name="value"></param><param name="flow_in"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayWriteV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayWriteV2(handle : TF, index : TF, value : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayWriteV2(handle.TFOutput, index.TFOutput, value.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Push an element onto the tensor_array.
    ///             </summary><param name="handle">
    ///               The handle to a TensorArray.
    ///             </param><param name="index">
    ///               The position to write to inside the TensorArray.
    ///             </param><param name="value">
    ///               The tensor to write to the TensorArray.
    ///             </param><param name="flow_in">
    ///               A float scalar that enforces proper chaining of operations.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorArrayWriteV3'.
    ///             </param><returns>
    ///               A float scalar that enforces proper chaining of operations.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorArrayWriteV3(handle : TF, index : TF, value : TF, flow_in : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorArrayWriteV3(handle.TFOutput, index.TFOutput, value.TFOutput, flow_in.TFOutput, operName))
    /// <summary>
    ///               Creates a dataset that emits <c>components</c> as a tuple of tensors once.
    ///             </summary><param name="components"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorDataset'.
    ///             </param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorDataset(components : TF[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorDataset(components |> Array.map (fun x -> x.TFOutput), output_shapes, operName))
    /// <summary>
    ///               The shape of the elements of the given list, as a tensor.
    ///             </summary><param name="input_handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListElementShape'.
    ///             </param><param name="shape_type"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               input_handle: the list
    ///               element_shape: the shape of elements of the list
    ///             </remarks>
    member this.TensorListElementShape(input_handle : TF, shape_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListElementShape(input_handle.TFOutput, shape_type, operName))
    /// <summary>
    ///               Creates a TensorList which, when stacked, has the value of <c>tensor</c>.
    ///             </summary><param name="tensor"></param><param name="element_shape"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListFromTensor'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Each tensor in the result list corresponds to one row of the input tensor.
    ///               
    ///               tensor: The input tensor.
    ///               output_handle: The list.
    ///             </remarks>
    member this.TensorListFromTensor(tensor : TF, element_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListFromTensor(tensor.TFOutput, element_shape.TFOutput, operName))
    /// <summary>
    ///               Creates a Tensor by indexing into the TensorList.
    ///             </summary><param name="input_handle"></param><param name="indices"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListGather'.
    ///             </param><param name="element_dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Each row in the produced Tensor corresponds to the element in the TensorList
    ///               specified by the given index (see <c>tf.gather</c>).
    ///               
    ///               input_handle: The input tensor list.
    ///               indices: The indices used to index into the list.
    ///               values: The tensor.
    ///             </remarks>
    member this.TensorListGather(input_handle : TF, indices : TF, element_dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListGather(input_handle.TFOutput, indices.TFOutput, element_dtype, operName))
    /// <summary>
    ///               Returns the item in the list with the given index.
    ///             </summary><param name="input_handle"></param><param name="index"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListGetItem'.
    ///             </param><param name="element_dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               input_handle: the list
    ///               index: the position in the list from which an element will be retrieved
    ///               item: the element at that position
    ///               
    ///               
    ///             </remarks>
    member this.TensorListGetItem(input_handle : TF, index : TF, element_dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListGetItem(input_handle.TFOutput, index.TFOutput, element_dtype, operName))
    /// <summary>
    ///               Returns the number of tensors in the input tensor list.
    ///             </summary><param name="input_handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListLength'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               input_handle: the input list
    ///               length: the number of tensors in the list
    ///             </remarks>
    member this.TensorListLength(input_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListLength(input_handle.TFOutput, operName))
    /// <summary>
    ///               Returns the last element of the input list as well as a list with all but that element.
    ///             </summary><param name="input_handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListPopBack'.
    ///             </param><param name="element_dtype"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_handle:
    ///               tensor:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Fails if the list is empty.
    ///               
    ///               input_handle: the input list
    ///               tensor: the withdrawn last element of the list
    ///               element_dtype: the type of elements in the list
    ///               element_shape: the shape of the output tensor
    ///             </remarks>
    member this.TensorListPopBack(input_handle : TF, element_dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.TensorListPopBack(input_handle.TFOutput, element_dtype, operName)
    /// <summary>
    ///               Returns a list list which has the passed-in <c>Tensor</c> as last element and the other elements of the given list in <c>input_handle</c>.
    ///             </summary><param name="input_handle"></param><param name="tensor"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListPushBack'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               tensor: The tensor to put on the list.
    ///               input_handle: The old list.
    ///               output_handle: A list with the elements of the old list followed by tensor.
    ///               element_dtype: the type of elements in the list.
    ///               element_shape: a shape compatible with that of elements in the list.
    ///             </remarks>
    member this.TensorListPushBack(input_handle : TF, tensor : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListPushBack(input_handle.TFOutput, tensor.TFOutput, operName))
    /// <summary>
    ///               List of the given size with empty elements.
    ///             </summary><param name="element_shape"></param><param name="num_elements"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListReserve'.
    ///             </param><param name="element_dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               element_shape: the shape of the future elements of the list
    ///               num_elements: the number of elements to reserve
    ///               handle: the output list
    ///               element_dtype: the desired type of elements in the list.
    ///             </remarks>
    member this.TensorListReserve(element_shape : TF, num_elements : TF, element_dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListReserve(element_shape.TFOutput, num_elements.TFOutput, element_dtype, operName))
    /// <summary>
    ///               Creates a TensorList by indexing into a Tensor.
    ///             </summary><param name="tensor"></param><param name="indices"></param><param name="element_shape"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListScatter'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Each member of the TensorList corresponds to one row of the input tensor,
    ///               specified by the given index (see <c>tf.gather</c>).
    ///               
    ///               tensor: The input tensor.
    ///               indices: The indices used to index into the list.
    ///               element_shape: The shape of the elements in the list (can be less specified than
    ///               the shape of the tensor).
    ///               output_handle: The TensorList.
    ///             </remarks>
    member this.TensorListScatter(tensor : TF, indices : TF, element_shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListScatter(tensor.TFOutput, indices.TFOutput, element_shape.TFOutput, operName))
    /// <summary>
    ///               Sets the index-th position of the list to contain the given tensor.
    ///             </summary><param name="input_handle"></param><param name="index"></param><param name="item"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListSetItem'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               input_handle: the list
    ///               index: the position in the list to which the tensor will be assigned
    ///               item: the element to be assigned to that position
    ///               output_handle: the new list, with the element in the proper position
    ///               
    ///             </remarks>
    member this.TensorListSetItem(input_handle : TF, index : TF, item : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListSetItem(input_handle.TFOutput, index.TFOutput, item.TFOutput, operName))
    /// <summary>
    ///               Stacks all tensors in the list.
    ///             </summary><param name="input_handle"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorListStack'.
    ///             </param><param name="num_elements">
    ///               Optional argument
    ///             </param><param name="element_dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Requires that all tensors have the same shape.
    ///               
    ///               input_handle: the input list
    ///               tensor: the gathered result
    ///               num_elements: optional. If not -1, the number of elements in the list.
    ///               
    ///             </remarks>
    member this.TensorListStack(input_handle : TF, element_dtype : TFDataType, ?num_elements : Int64, ?operName : String) =
        let num_elements = defaultArg (num_elements |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorListStack(input_handle.TFOutput, element_dtype, num_elements, operName))
    /// <summary>
    ///               Creates a dataset that emits each dim-0 slice of <c>components</c> once.
    ///             </summary><param name="components"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorSliceDataset'.
    ///             </param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorSliceDataset(components : TF[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorSliceDataset(components |> Array.map (fun x -> x.TFOutput), output_shapes, operName))
    /// <summary>
    ///               Outputs a <c>Summary</c> protocol buffer with a tensor.
    ///             </summary><param name="tensor">
    ///               A tensor to serialize.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorSummary'.
    ///             </param><param name="description">
    ///               Optional argument
    ///               A json-encoded SummaryDescription proto.
    ///             </param><param name="labels">
    ///               Optional argument
    ///               An unused list of strings.
    ///             </param><param name="display_name">
    ///               Optional argument
    ///               An unused string.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op is being phased out in favor of TensorSummaryV2, which lets callers pass
    ///               a tag as well as a serialized SummaryMetadata proto string that contains
    ///               plugin-specific data. We will keep this op to maintain backwards compatibility.
    ///             </remarks>
    member this.TensorSummary(tensor : TF, ?description : String, ?labels : String[], ?display_name : String, ?operName : String) =
        let description = defaultArg description null
        let labels = defaultArg labels null
        let display_name = defaultArg display_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorSummary(tensor.TFOutput, description, labels, display_name, operName))
    /// <summary>
    ///               Outputs a <c>Summary</c> protocol buffer with a tensor and per-plugin data.
    ///             </summary><param name="tag">
    ///               A string attached to this summary. Used for organization in TensorBoard.
    ///             </param><param name="tensor">
    ///               A tensor to serialize.
    ///             </param><param name="serialized_summary_metadata">
    ///               A serialized SummaryMetadata proto. Contains plugin
    ///               data.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TensorSummaryV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TensorSummaryV2(tag : TF, tensor : TF, serialized_summary_metadata : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TensorSummaryV2(tag.TFOutput, tensor.TFOutput, serialized_summary_metadata.TFOutput, operName))
    /// <summary>
    ///               Creates a dataset that emits the lines of one or more text files.
    ///             </summary><param name="filenames">
    ///               A scalar or a vector containing the name(s) of the file(s) to be
    ///               read.
    ///             </param><param name="compression_type">
    ///               A scalar containing either (i) the empty string (no
    ///               compression), (ii) "ZLIB", or (iii) "GZIP".
    ///             </param><param name="buffer_size">
    ///               A scalar containing the number of bytes to buffer.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TextLineDataset'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TextLineDataset(filenames : TF, compression_type : TF, buffer_size : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TextLineDataset(filenames.TFOutput, compression_type.TFOutput, buffer_size.TFOutput, operName))
    /// <summary>
    ///               A Reader that outputs the lines of a file delimited by '\n'.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TextLineReader'.
    ///             </param><param name="skip_header_lines">
    ///               Optional argument
    ///               Number of lines to skip from the beginning of every file.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this reader is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this reader is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><returns>
    ///               The handle to reference the Reader.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TextLineReader(?skip_header_lines : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let skip_header_lines = defaultArg (skip_header_lines |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TextLineReader(skip_header_lines, container, shared_name, operName))
    /// <summary>
    ///               A Reader that outputs the lines of a file delimited by '\n'.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TextLineReaderV2'.
    ///             </param><param name="skip_header_lines">
    ///               Optional argument
    ///               Number of lines to skip from the beginning of every file.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this reader is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this reader is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><returns>
    ///               The handle to reference the Reader.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TextLineReaderV2(?skip_header_lines : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let skip_header_lines = defaultArg (skip_header_lines |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TextLineReaderV2(skip_header_lines, container, shared_name, operName))
    /// <summary>
    ///               Creates a dataset that emits the records from one or more TFRecord files.
    ///             </summary><param name="filenames">
    ///               A scalar or vector containing the name(s) of the file(s) to be
    ///               read.
    ///             </param><param name="compression_type">
    ///               A scalar containing either (i) the empty string (no
    ///               compression), (ii) "ZLIB", or (iii) "GZIP".
    ///             </param><param name="buffer_size">
    ///               A scalar representing the number of bytes to buffer. A value of
    ///               0 means no buffering will be performed.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TFRecordDataset'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TFRecordDataset(filenames : TF, compression_type : TF, buffer_size : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TFRecordDataset(filenames.TFOutput, compression_type.TFOutput, buffer_size.TFOutput, operName))
    /// <summary>
    ///               A Reader that outputs the records from a TensorFlow Records file.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TFRecordReader'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this reader is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this reader is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><param name="compression_type">
    ///               Optional argument
    ///             </param><returns>
    ///               The handle to reference the Reader.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TFRecordReader(?container : String, ?shared_name : String, ?compression_type : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let compression_type = defaultArg compression_type null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TFRecordReader(container, shared_name, compression_type, operName))
    /// <summary>
    ///               A Reader that outputs the records from a TensorFlow Records file.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TFRecordReaderV2'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this reader is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this reader is named in the given bucket
    ///               with this shared_name. Otherwise, the node name is used instead.
    ///             </param><param name="compression_type">
    ///               Optional argument
    ///             </param><returns>
    ///               The handle to reference the Reader.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TFRecordReaderV2(?container : String, ?shared_name : String, ?compression_type : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let compression_type = defaultArg compression_type null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TFRecordReaderV2(container, shared_name, compression_type, operName))
    /// <summary>
    ///               Generates labels for candidate sampling with a learned unigram distribution.
    ///             </summary><param name="true_classes">
    ///               A batch_size * num_true matrix, in which each row contains the
    ///               IDs of the num_true target_classes in the corresponding original label.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ThreadUnsafeUnigramCandidateSampler'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either seed or seed2 are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               An second seed to avoid seed collision.
    ///             </param><param name="num_true">
    ///               Number of true labels per context.
    ///             </param><param name="num_sampled">
    ///               Number of candidates to randomly sample.
    ///             </param><param name="unique">
    ///               If unique is true, we sample with rejection, so that all sampled
    ///               candidates in a batch are unique. This requires some approximation to
    ///               estimate the post-rejection sampling probabilities.
    ///             </param><param name="range_max">
    ///               The sampler will sample integers from the interval [0, range_max).
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               sampled_candidates: A vector of length num_sampled, in which each element is
    ///               the ID of a sampled candidate.
    ///               true_expected_count: A batch_size * num_true matrix, representing
    ///               the number of times each candidate is expected to occur in a batch
    ///               of sampled candidates. If unique=true, then this is a probability.
    ///               sampled_expected_count: A vector of length num_sampled, for each sampled
    ///               candidate representing the number of times the candidate is expected
    ///               to occur in a batch of sampled candidates.  If unique=true, then this is a
    ///               probability.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               See explanations of candidate sampling and the data formats at
    ///               go/candidate-sampling.
    ///               
    ///               For each batch, this op picks a single set of sampled candidate labels.
    ///               
    ///               The advantages of sampling candidates per-batch are simplicity and the
    ///               possibility of efficient dense matrix multiplication. The disadvantage is that
    ///               the sampled candidates must be chosen independently of the context and of the
    ///               true labels.
    ///             </remarks>
    member this.ThreadUnsafeUnigramCandidateSampler(true_classes : TF, num_true : Int64, num_sampled : Int64, unique : Boolean, range_max : Int64, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ThreadUnsafeUnigramCandidateSampler(true_classes.TFOutput, num_true, num_sampled, unique, range_max, seed, seed2, operName)
    /// <summary>
    ///               Constructs a tensor by tiling a given tensor.
    ///             </summary><param name="input">
    ///               1-D or higher.
    ///             </param><param name="multiples">
    ///               1-D. Length must be the same as the number of dimensions in <c>input</c></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Tile'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation creates a new tensor by replicating <c>input</c><c>multiples</c> times.
    ///               The output tensor's i'th dimension has <c>input.dims(i) * multiples[i]</c> elements,
    ///               and the values of <c>input</c> are replicated <c>multiples[i]</c> times along the 'i'th
    ///               dimension. For example, tiling <c>[a b c d]</c> by <c>[2]</c> produces
    ///               <c>[a b c d a b c d]</c>.
    ///             </remarks>
    member this.Tile(input : TF, multiples : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Tile(input.TFOutput, multiples.TFOutput, operName))
    /// <summary>
    ///               Returns the gradient of <c>Tile</c>.
    ///             </summary><param name="input"></param><param name="multiples"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TileGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Since <c>Tile</c> takes an input and repeats the input <c>multiples</c> times
    ///               along each dimension, <c>TileGrad</c> takes in <c>multiples</c> and aggregates
    ///               each repeated tile of <c>input</c> into <c>output</c>.
    ///             </remarks>
    member this.TileGrad(input : TF, multiples : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TileGrad(input.TFOutput, multiples.TFOutput, operName))
    /// <summary>
    ///               Provides the time since epoch in seconds.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Timestamp'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Returns the timestamp as a <c>float64</c> for seconds since the Unix epoch.
    ///               
    ///               Note: the timestamp is computed when the op is executed, not when it is added
    ///               to the graph.
    ///             </remarks>
    member this.Timestamp(?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Timestamp(operName))
    /// <summary>
    ///               Finds values and indices of the <c>k</c> largest elements for the last dimension.
    ///             </summary><param name="input">
    ///               1-D or higher with last dimension at least <c>k</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TopK'.
    ///             </param><param name="sorted">
    ///               Optional argument
    ///               If true the resulting <c>k</c> elements will be sorted by the values in
    ///               descending order.
    ///             </param><param name="k">
    ///               Number of top elements to look for along the last dimension (along each
    ///               row for matrices).
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               values: The <c>k</c> largest elements along each last dimensional slice.
    ///               indices: The indices of <c>values</c> within the last dimension of <c>input</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               If the input is a vector (rank-1), finds the <c>k</c> largest entries in the vector
    ///               and outputs their values and indices as vectors.  Thus <c>values[j]</c> is the
    ///               <c>j</c>-th largest entry in <c>input</c>, and its index is <c>indices[j]</c>.
    ///               
    ///               For matrices (resp. higher rank input), computes the top <c>k</c> entries in each
    ///               row (resp. vector along the last dimension).  Thus,
    ///               
    ///               values.shape = indices.shape = input.shape[:-1] + [k]
    ///               
    ///               If two elements are equal, the lower-index element appears first.
    ///               
    ///               If <c>k</c> varies dynamically, use <c>TopKV2</c> below.
    ///             </remarks>
    member this.TopK(input : TF, k : Int64, ?sorted : Boolean, ?operName : String) =
        let sorted = defaultArg (sorted |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.TopK(input.TFOutput, k, sorted, operName)
    /// <summary>
    ///               Finds values and indices of the <c>k</c> largest elements for the last dimension.
    ///             </summary><param name="input">
    ///               1-D or higher with last dimension at least <c>k</c>.
    ///             </param><param name="k">
    ///               0-D.  Number of top elements to look for along the last dimension (along each
    ///               row for matrices).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TopKV2'.
    ///             </param><param name="sorted">
    ///               Optional argument
    ///               If true the resulting <c>k</c> elements will be sorted by the values in
    ///               descending order.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               values: The <c>k</c> largest elements along each last dimensional slice.
    ///               indices: The indices of <c>values</c> within the last dimension of <c>input</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               If the input is a vector (rank-1), finds the <c>k</c> largest entries in the vector
    ///               and outputs their values and indices as vectors.  Thus <c>values[j]</c> is the
    ///               <c>j</c>-th largest entry in <c>input</c>, and its index is <c>indices[j]</c>.
    ///               
    ///               For matrices (resp. higher rank input), computes the top <c>k</c> entries in each
    ///               row (resp. vector along the last dimension).  Thus,
    ///               
    ///               values.shape = indices.shape = input.shape[:-1] + [k]
    ///               
    ///               If two elements are equal, the lower-index element appears first.
    ///             </remarks>
    member this.TopKV2(input : TF, k : TF, ?sorted : Boolean, ?operName : String) =
        let sorted = defaultArg (sorted |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.TopKV2(input.TFOutput, k.TFOutput, sorted, operName)
    /// <summary>
    ///               An op enabling differentiation of TPU Embeddings.
    ///             </summary><param name="embedding_variable">
    ///               A trainable variable, enabling optimizers to find this op.
    ///             </param><param name="sliced_activations">
    ///               The embedding activations Tensor to return.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TPUEmbeddingActivations'.
    ///             </param><param name="table_id">
    ///               The id of the table in the embedding layer configuration from which
    ///               these activations were computed.
    ///             </param><param name="lookup_id">
    ///               Identifier of the set of embedding indices which produced these
    ///               activations.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op simply returns its first input, which is assumed to have been sliced
    ///               from the Tensors returned by TPUEmbeddingDequeueActivations. The presence of this
    ///               op, and its first argument being a trainable Variable, enables automatic
    ///               differentiation of graphs containing embeddings via the TPU Embedding Python
    ///               libraries.
    ///             </remarks>
    member this.TPUEmbeddingActivations(embedding_variable : TF, sliced_activations : TF, table_id : Int64, lookup_id : Int64, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TPUEmbeddingActivations(embedding_variable.TFOutput, sliced_activations.TFOutput, table_id, lookup_id, operName))
    /// <summary>
    ///               Operator that connects N unreplicated inputs to an N-way replicated TPU computation.
    ///             </summary><param name="inputs"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TPUReplicatedInput'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TPUReplicatedInput(inputs : TF[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TPUReplicatedInput(inputs |> Array.map (fun x -> x.TFOutput), operName))
    /// <summary>
    ///               Operator that connects the output of an N-way replicated TPU computation to N separate outputs.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TPUReplicatedOutput'.
    ///             </param><param name="num_replicas"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.TPUReplicatedOutput(input : TF, num_replicas : Int64, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.TPUReplicatedOutput(input.TFOutput, num_replicas, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Shuffle dimensions of x according to a permutation.
    ///             </summary><param name="x"></param><param name="perm"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Transpose'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The output <c>y</c> has the same rank as <c>x</c>. The shapes of <c>x</c> and <c>y</c> satisfy:
    ///               <c>y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]</c></remarks>
    member this.Transpose(x : TF, perm : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Transpose(x.TFOutput, perm.TFOutput, operName))
    /// <summary>
    ///               Returns x / y element-wise for integer types.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TruncateDiv'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Truncation designates that negative numbers will round fractional quantities
    ///               toward zero. I.e. -7 / 5 = -1. This matches C semantics but it is different
    ///               than Python semantics. See <c>FloorDiv</c> for a division function that matches
    ///               Python Semantics.
    ///               
    ///               *NOTE*: <c>TruncateDiv</c> supports broadcasting. More about broadcasting
    ///               [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///             </remarks>
    member this.TruncateDiv(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TruncateDiv(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Outputs random values from a truncated normal distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TruncatedNormal'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="dtype">
    ///               The type of the output.
    ///             </param><returns>
    ///               A tensor of the specified shape filled with random truncated normal
    ///               values.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values follow a normal distribution with mean 0 and standard
    ///               deviation 1, except that values whose magnitude is more than 2 standard
    ///               deviations from the mean are dropped and re-picked.
    ///             </remarks>
    member this.TruncatedNormal(shape : TF, dtype : TFDataType, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TruncatedNormal(shape.TFOutput, dtype, seed, seed2, operName))
    /// <summary>
    ///               Returns element-wise remainder of division. This emulates C semantics in that
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TruncateMod'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               the result here is consistent with a truncating divide. E.g. <c>truncate(x / y) *
    ///               y + truncate_mod(x, y) = x</c>.
    ///               
    ///               *NOTE*: <c>TruncateMod</c> supports broadcasting. More about broadcasting
    ///               [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///             </remarks>
    member this.TruncateMod(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.TruncateMod(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Perform batches of RPC requests.
    ///             </summary><param name="address"><c>0-D</c> or <c>1-D</c>.  The address (i.e. host_name:port) of the RPC server.
    ///               If this tensor has more than 1 element, then multiple parallel rpc requests
    ///               are sent.  This argument broadcasts with <c>method</c> and <c>request</c>.
    ///             </param><param name="method"><c>0-D</c> or <c>1-D</c>.  The method address on the RPC server.
    ///               If this tensor has more than 1 element, then multiple parallel rpc requests
    ///               are sent.  This argument broadcasts with <c>address</c> and <c>request</c>.
    ///             </param><param name="request"><c>0-D</c> or <c>1-D</c>.  Serialized proto strings: the rpc request argument.
    ///               If this tensor has more than 1 element, then multiple parallel rpc requests
    ///               are sent.  This argument broadcasts with <c>address</c> and <c>method</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'TryRpc'.
    ///             </param><param name="protocol">
    ///               Optional argument
    ///               RPC protocol to use.  Empty string means use the default protocol.
    ///               Options include 'grpc'.
    ///             </param><param name="fail_fast">
    ///               Optional argument
    ///               <c>boolean</c>. If <c>true</c> (default), then failures to connect
    ///               (i.e., the server does not immediately respond) cause an RPC failure.
    ///             </param><param name="timeout_in_ms">
    ///               Optional argument
    ///               <c>int</c>. If <c>0</c> (default), then the kernel will run the RPC
    ///               request and only time out if the RPC deadline passes or the session times out.
    ///               If this value is greater than <c>0</c>, then the op will raise an exception if
    ///               the RPC takes longer than <c>timeout_in_ms</c>.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               response: Same shape as <c>request</c>. Serialized proto strings: the rpc responses.
    ///               status_code: Same shape as <c>request</c>.  Values correspond to tensorflow Status enum codes.
    ///               status_message: Same shape as <c>request</c>.  Values correspond to Status messages
    ///               returned from the RPC calls.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This op asynchronously performs either a single RPC request, or a batch
    ///               of requests.  RPC requests are defined by three main parameters:
    ///               
    ///               - <c>address</c> (the host+port or BNS address of the request)
    ///               - <c>method</c> (the method name for the request)
    ///               - <c>request</c> (the serialized proto string, or vector of strings,
    ///               of the RPC request argument).
    ///               
    ///               For example, if you have an RPC service running on port localhost:2345,
    ///               and its interface is configured with the following proto declaration:
    ///               
    ///                <code>
    ///               service MyService {
    ///               rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
    ///               }
    ///               };
    ///                </code>
    ///               
    ///               then call this op with arguments:
    ///               
    ///                <code>
    ///               address = "localhost:2345"
    ///               method = "MyService/MyMethod"
    ///                </code>
    ///               
    ///               The <c>request</c> tensor is a string tensor representing serialized <c>MyRequestProto</c>
    ///               strings; and the output string tensor <c>response</c> will have the same shape
    ///               and contain (upon successful completion) corresponding serialized
    ///               <c>MyResponseProto</c> strings.
    ///               
    ///               For example, to send a single, empty, <c>MyRequestProto</c>, call
    ///               this op with <c>request = ""</c>.  To send 5 **parallel** empty requests,
    ///               call this op with <c>request = ["", "", "", "", ""]</c>.
    ///               
    ///               More generally, one can create a batch of <c>MyRequestProto</c> serialized protos
    ///               from regular batched tensors using the <c>encode_proto</c> op, and convert
    ///               the response <c>MyResponseProto</c> serialized protos to batched tensors
    ///               using the <c>decode_proto</c> op.
    ///               
    ///               **NOTE** Working with serialized proto strings is faster than instantiating
    ///               actual proto objects in memory, so no performance degradation is expected
    ///               compared to writing custom kernels for this workflow.
    ///               
    ///               Unlike the standard <c>Rpc</c> op, if the connection fails or the remote worker
    ///               returns an error status, this op does **not** reraise the exception.
    ///               Instead, the <c>status_code</c> and <c>status_message</c> entry for the corresponding RPC
    ///               call is set with the error returned from the RPC call.  The <c>response</c> tensor
    ///               will contain valid response values for those minibatch entries whose RPCs did
    ///               not fail; the rest of the entries will have empty strings.
    ///             </remarks>
    member this.TryRpc(address : TF, method : TF, request : TF, ?protocol : String, ?fail_fast : Boolean, ?timeout_in_ms : Int64, ?operName : String) =
        let protocol = defaultArg protocol null
        let fail_fast = defaultArg (fail_fast |> Option.map Nullable) (Nullable())
        let timeout_in_ms = defaultArg (timeout_in_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.TryRpc(address.TFOutput, method.TFOutput, request.TFOutput, protocol, fail_fast, timeout_in_ms, operName)
    /// <summary>
    ///               Reverses the operation of Batch for a single output Tensor.
    ///             </summary><param name="batched_tensor"></param><param name="batch_index"></param><param name="id"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Unbatch'.
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="timeout_micros"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               An instance of Unbatch either receives an empty batched_tensor, in which case it
    ///               asynchronously waits until the values become available from a concurrently
    ///               running instance of Unbatch with the same container and shared_name, or receives
    ///               a non-empty batched_tensor in which case it finalizes all other concurrently
    ///               running instances and outputs its own element from the batch.
    ///               
    ///               batched_tensor: The possibly transformed output of Batch. The size of the first
    ///               dimension should remain unchanged by the transformations for the operation to
    ///               work.
    ///               batch_index: The matching batch_index obtained from Batch.
    ///               id: The id scalar emitted by Batch.
    ///               unbatched_tensor: The Tensor corresponding to this execution.
    ///               timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
    ///               batched input tensor associated with a given invocation of the op.
    ///               container: Container to control resource sharing.
    ///               shared_name: Instances of Unbatch with the same container and shared_name are
    ///               assumed to possibly belong to the same batch. If left empty, the op name will
    ///               be used as the shared name.
    ///             </remarks>
    member this.Unbatch(batched_tensor : TF, batch_index : TF, id : TF, timeout_micros : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Unbatch(batched_tensor.TFOutput, batch_index.TFOutput, id.TFOutput, timeout_micros, container, shared_name, operName))
    /// <summary>
    ///               Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyProximalAdagrad'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var and accum as follows:
    ///               accum += grad * grad
    ///               prox_v = var
    ///               prox_v -= lr * grad * (1 / sqrt(accum))
    ///               var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
    ///             </remarks>
    member this.ResourceSparseApplyProximalAdagrad(var : TF, accum : TF, lr : TF, l1 : TF, l2 : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyProximalAdagrad(var.TFOutput, accum.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName)
    /// <summary>
    ///               Sparse update '*var' as FOBOS algorithm with fixed learning rate.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="alpha">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyProximalGradientDescent'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the subtraction will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var as follows:
    ///               prox_v = var - alpha * grad
    ///               var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
    ///             </remarks>
    member this.ResourceSparseApplyProximalGradientDescent(var : TF, alpha : TF, l1 : TF, l2 : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyProximalGradientDescent(var.TFOutput, alpha.TFOutput, l1.TFOutput, l2.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the RMSProp algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="ms">
    ///               Should be from a Variable().
    ///             </param><param name="mom">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay rate. Must be a scalar.
    ///             </param><param name="momentum"></param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var, ms and mom.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyRMSProp'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, ms, and mom tensors is protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               Note that in dense implementation of this algorithm, ms and mom will
    ///               update even if the grad is zero, but in this sparse implementation, ms
    ///               and mom will not update in iterations during which the grad is zero.
    ///               
    ///               mean_square = decay * mean_square + (1-decay) * gradient ** 2
    ///               Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
    ///               
    ///               ms &amp;lt;- rho * ms_{t-1} + (1-rho) * grad * grad
    ///               mom &amp;lt;- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
    ///               var &amp;lt;- var - mom
    ///             </remarks>
    member this.ResourceSparseApplyRMSProp(var : TF, ms : TF, mom : TF, lr : TF, rho : TF, momentum : TF, epsilon : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyRMSProp(var.TFOutput, ms.TFOutput, mom.TFOutput, lr.TFOutput, rho.TFOutput, momentum.TFOutput, epsilon.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName)
    member this.ResourceStridedSliceAssign(reference : TF, ``begin`` : TF, ``end`` : TF, strides : TF, value : TF, ?begin_mask : Int64, ?end_mask : Int64, ?ellipsis_mask : Int64, ?new_axis_mask : Int64, ?shrink_axis_mask : Int64, ?operName : String) =
        let begin_mask = defaultArg (begin_mask |> Option.map Nullable) (Nullable())
        let end_mask = defaultArg (end_mask |> Option.map Nullable) (Nullable())
        let ellipsis_mask = defaultArg (ellipsis_mask |> Option.map Nullable) (Nullable())
        let new_axis_mask = defaultArg (new_axis_mask |> Option.map Nullable) (Nullable())
        let shrink_axis_mask = defaultArg (shrink_axis_mask |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceStridedSliceAssign(reference.TFOutput, ``begin``.TFOutput, ``end``.TFOutput, strides.TFOutput, value.TFOutput, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask, operName)
    /// <summary>
    ///               Restores a tensor from checkpoint files.
    ///             </summary><param name="file_pattern">
    ///               Must have a single element. The pattern of the files from
    ///               which we read the tensor.
    ///             </param><param name="tensor_name">
    ///               Must have a single element. The name of the tensor to be
    ///               restored.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Restore'.
    ///             </param><param name="preferred_shard">
    ///               Optional argument
    ///               Index of file to open first if multiple files match
    ///               <c>file_pattern</c>.
    ///             </param><param name="dt">
    ///               The type of the tensor to be restored.
    ///             </param><returns>
    ///               The restored tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Reads a tensor stored in one or several files. If there are several files (for
    ///               instance because a tensor was saved as slices), <c>file_pattern</c> may contain
    ///               wildcard symbols (<c>*</c> and <c>?</c>) in the filename portion only, not in the
    ///               directory portion.
    ///               
    ///               If a <c>file_pattern</c> matches several files, <c>preferred_shard</c> can be used to hint
    ///               in which file the requested tensor is likely to be found. This op will first
    ///               open the file at index <c>preferred_shard</c> in the list of matching files and try
    ///               to restore tensors from that file.  Only if some tensors or tensor slices are
    ///               not found in that first file, then the Op opens all the files. Setting
    ///               <c>preferred_shard</c> to match the value passed as the <c>shard</c> input
    ///               of a matching <c>Save</c> Op may speed up Restore.  This attribute only affects
    ///               performance, not correctness.  The default value -1 means files are processed in
    ///               order.
    ///               
    ///               See also <c>RestoreSlice</c>.
    ///             </remarks>
    member this.Restore(file_pattern : TF, tensor_name : TF, dt : TFDataType, ?preferred_shard : Int64, ?operName : String) =
        let preferred_shard = defaultArg (preferred_shard |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Restore(file_pattern.TFOutput, tensor_name.TFOutput, dt, preferred_shard, operName))
    /// <summary>
    ///               Restores a tensor from checkpoint files.
    ///             </summary><param name="file_pattern">
    ///               Must have a single element. The pattern of the files from
    ///               which we read the tensor.
    ///             </param><param name="tensor_name">
    ///               Must have a single element. The name of the tensor to be
    ///               restored.
    ///             </param><param name="shape_and_slice">
    ///               Scalar. The shapes and slice specifications to use when
    ///               restoring a tensors.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RestoreSlice'.
    ///             </param><param name="preferred_shard">
    ///               Optional argument
    ///               Index of file to open first if multiple files match
    ///               <c>file_pattern</c>. See the documentation for <c>Restore</c>.
    ///             </param><param name="dt">
    ///               The type of the tensor to be restored.
    ///             </param><returns>
    ///               The restored tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This is like <c>Restore</c> except that restored tensor can be listed as filling
    ///               only a slice of a larger tensor.  <c>shape_and_slice</c> specifies the shape of the
    ///               larger tensor and the slice that the restored tensor covers.
    ///               
    ///               The <c>shape_and_slice</c> input has the same format as the
    ///               elements of the <c>shapes_and_slices</c> input of the <c>SaveSlices</c> op.
    ///             </remarks>
    member this.RestoreSlice(file_pattern : TF, tensor_name : TF, shape_and_slice : TF, dt : TFDataType, ?preferred_shard : Int64, ?operName : String) =
        let preferred_shard = defaultArg (preferred_shard |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RestoreSlice(file_pattern.TFOutput, tensor_name.TFOutput, shape_and_slice.TFOutput, dt, preferred_shard, operName))
    /// <summary>
    ///               Restores tensors from a V2 checkpoint.
    ///             </summary><param name="prefix">
    ///               Must have a single element.  The prefix of a V2 checkpoint.
    ///             </param><param name="tensor_names">
    ///               shape {N}.  The names of the tensors to be restored.
    ///             </param><param name="shape_and_slices">
    ///               shape {N}.  The slice specs of the tensors to be restored.
    ///               Empty strings indicate that they are non-partitioned tensors.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RestoreV2'.
    ///             </param><param name="dtypes">
    ///               shape {N}.  The list of expected dtype for the tensors.  Must match
    ///               those stored in the checkpoint.
    ///             </param><returns>
    ///               shape {N}.  The restored tensors, whose shapes are read from the
    ///               checkpoint directly.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               For backward compatibility with the V1 format, this Op currently allows
    ///               restoring from a V1 checkpoint as well:
    ///               - This Op first attempts to find the V2 index file pointed to by "prefix", and
    ///               if found proceed to read it as a V2 checkpoint;
    ///               - Otherwise the V1 read path is invoked.
    ///               Relying on this behavior is not recommended, as the ability to fall back to read
    ///               V1 might be deprecated and eventually removed.
    ///               
    ///               By default, restores the named tensors in full.  If the caller wishes to restore
    ///               specific slices of stored tensors, "shape_and_slices" should be non-empty
    ///               strings and correspondingly well-formed.
    ///               
    ///               Callers must ensure all the named tensors are indeed stored in the checkpoint.
    ///             </remarks>
    member this.RestoreV2(prefix : TF, tensor_names : TF, shape_and_slices : TF, dtypes : TFDataType[], ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.RestoreV2(prefix.TFOutput, tensor_names.TFOutput, shape_and_slices.TFOutput, dtypes, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingAdadeltaParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the Adadelta optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
    ///               updates: Parameter updates updated by the Adadelta optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               updates: A tensor containing the embedding table updates to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingAdadeltaParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingAdadeltaParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the Adadelta optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
    ///               updates: Parameter updates updated by the Adadelta optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the Adadelta optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               updates: A tensor containing the embedding table updates to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the Adadelta optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingAdagradParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the Adagrad optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the Adagrad optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the Adagrad optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingAdagradParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingAdagradParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingAdagradParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the Adagrad optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the Adagrad optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the Adagrad optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the Adagrad optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the Adagrad optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingAdagradParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingAdagradParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingADAMParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the ADAM optimization algorithm.
    ///               momenta: Parameter momenta updated by the ADAM optimization algorithm.
    ///               velocities: Parameter velocities updated by the ADAM optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               momenta: A tensor containing the embedding table momenta to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               velocities: A tensor containing the embedding table velocities to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingADAMParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingADAMParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingADAMParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the ADAM optimization algorithm.
    ///               momenta: Parameter momenta updated by the ADAM optimization algorithm.
    ///               velocities: Parameter velocities updated by the ADAM optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the ADAM optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               momenta: A tensor containing the embedding table momenta to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               velocities: A tensor containing the embedding table velocities to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the ADAM optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingADAMParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingADAMParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingCenteredRMSPropParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the centered RMSProp optimization algorithm.
    ///               ms: Parameter ms updated by the centered RMSProp optimization algorithm.
    ///               mom: Parameter mom updated by the centered RMSProp optimization algorithm.
    ///               mg: Parameter mg updated by the centered RMSProp optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the centered RMSProp optimization algorithm.
    ///               ms: A tensor containing the embedding table ms to store with the
    ///               parameters from embedding updates using the centered RMSProp optimization algorithm.
    ///               mom: A tensor containing the embedding table mom to store with the
    ///               parameters from embedding updates using the centered RMSProp optimization algorithm.
    ///               mg: A tensor containing the embedding table mg to store with the
    ///               parameters from embedding updates using the centered RMSProp optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingCenteredRMSPropParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingCenteredRMSPropParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingFTRLParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the FTRL optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
    ///               linears: Parameter linears updated by the FTRL optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               linears: A tensor containing the embedding table linears to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingFTRLParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingFTRLParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingFTRLParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the FTRL optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
    ///               linears: Parameter linears updated by the FTRL optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the FTRL optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               linears: A tensor containing the embedding table linears to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the FTRL optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingFTRLParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingFTRLParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingMDLAdagradLightParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the MDL Adagrad Light optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the MDL Adagrad Light optimization algorithm.
    ///               weights: Parameter weights updated by the MDL Adagrad Light optimization algorithm.
    ///               benefits: Parameter benefits updated by the MDL Adagrad Light optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the MDL Adagrad Light optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the MDL Adagrad Light optimization algorithm.
    ///               weights: A tensor containing the embedding table weights to store with the
    ///               parameters from embedding updates using the MDL Adagrad Light optimization algorithm.
    ///               benefits: A tensor containing the embedding table benefits to store with the
    ///               parameters from embedding updates using the MDL Adagrad Light optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingMDLAdagradLightParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingMDLAdagradLightParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingMomentumParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the Momentum optimization algorithm.
    ///               momenta: Parameter momenta updated by the Momentum optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the Momentum optimization algorithm.
    ///               momenta: A tensor containing the embedding table momenta to store with the
    ///               parameters from embedding updates using the Momentum optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingMomentumParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingMomentumParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingMomentumParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the Momentum optimization algorithm.
    ///               momenta: Parameter momenta updated by the Momentum optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the Momentum optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the Momentum optimization algorithm.
    ///               momenta: A tensor containing the embedding table momenta to store with the
    ///               parameters from embedding updates using the Momentum optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the Momentum optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingMomentumParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingMomentumParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingProximalAdagradParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the proximal Adagrad optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the proximal Adagrad optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingProximalAdagradParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingProximalAdagradParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
    ///               accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the proximal Adagrad optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the proximal Adagrad optimization algorithm.
    ///               accumulators: A tensor containing the embedding table accumulators to store with the
    ///               parameters from embedding updates using the proximal Adagrad optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the proximal Adagrad optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingRMSPropParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the RMSProp optimization algorithm.
    ///               ms: Parameter ms updated by the RMSProp optimization algorithm.
    ///               mom: Parameter mom updated by the RMSProp optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               ms: A tensor containing the embedding table ms to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               mom: A tensor containing the embedding table mom to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingRMSPropParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingRMSPropParameters(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               parameters: Parameter parameters updated by the RMSProp optimization algorithm.
    ///               ms: Parameter ms updated by the RMSProp optimization algorithm.
    ///               mom: Parameter mom updated by the RMSProp optimization algorithm.
    ///               gradient_accumulators: Parameter gradient_accumulators updated by the RMSProp optimization algorithm.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               ms: A tensor containing the embedding table ms to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               mom: A tensor containing the embedding table mom to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               gradient_accumulators: A tensor containing the embedding table gradient_accumulators to store with the
    ///               parameters from embedding updates using the RMSProp optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        this.TFGraph.RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug(num_shards, shard_id, table_id, table_name, operName)
    /// <summary>
    ///               Retrieve embedding parameters for a single table.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RetrieveTPUEmbeddingStochasticGradientDescentParameters'.
    ///             </param><param name="table_id">
    ///               Optional argument
    ///             </param><param name="table_name">
    ///               Optional argument
    ///             </param><param name="num_shards"></param><param name="shard_id"></param><returns>
    ///               Parameter parameters updated by the stochastic gradient descent optimization algorithm.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               
    ///               An op that retrieves optimization parameters from embedding to host
    ///               memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
    ///               the correct embedding table configuration. For example, this op is
    ///               used to retrieve updated parameters before saving a checkpoint.
    ///               
    ///               parameters: A tensor containing the embedding table parameters to store with the
    ///               parameters from embedding updates using the stochastic gradient descent optimization algorithm.
    ///               table_name: Name of this table; must match a name in the
    ///               TPUEmbeddingConfiguration proto (overrides table_id).
    ///               num_shards: Number of shards into which the embedding tables are divided.
    ///               shard_id: Identifier of shard for this operation.
    ///               table_id: Index of this table in the EmbeddingLayerConfiguration proto
    ///               (deprecated).
    ///               
    ///             </remarks>
    member this.RetrieveTPUEmbeddingStochasticGradientDescentParameters(num_shards : Int64, shard_id : Int64, ?table_id : Int64, ?table_name : String, ?operName : String) =
        let table_id = defaultArg (table_id |> Option.map Nullable) (Nullable())
        let table_name = defaultArg table_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RetrieveTPUEmbeddingStochasticGradientDescentParameters(num_shards, shard_id, table_id, table_name, operName))
    /// <summary>
    ///               Reverses specific dimensions of a tensor.
    ///             </summary><param name="tensor">
    ///               Up to 8-D.
    ///             </param><param name="dims">
    ///               1-D. The dimensions to reverse.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Reverse'.
    ///             </param><returns>
    ///               The same shape as <c>tensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Given a <c>tensor</c>, and a <c>bool</c> tensor <c>dims</c> representing the dimensions
    ///               of <c>tensor</c>, this operation reverses each dimension i of <c>tensor</c> where
    ///               <c>dims[i]</c> is <c>True</c>.
    ///               
    ///               <c>tensor</c> can have up to 8 dimensions. The number of dimensions
    ///               of <c>tensor</c> must equal the number of elements in <c>dims</c>. In other words:
    ///               
    ///               <c>rank(tensor) = size(dims)</c>
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor 't' is [[[[ 0,  1,  2,  3],
    ///               #                  [ 4,  5,  6,  7],
    ///               #                  [ 8,  9, 10, 11]],
    ///               #                 [[12, 13, 14, 15],
    ///               #                  [16, 17, 18, 19],
    ///               #                  [20, 21, 22, 23]]]]
    ///               # tensor 't' shape is [1, 2, 3, 4]
    ///               
    ///               # 'dims' is [False, False, False, True]
    ///               reverse(t, dims) ==&amp;gt; [[[[ 3,  2,  1,  0],
    ///               [ 7,  6,  5,  4],
    ///               [ 11, 10, 9, 8]],
    ///               [[15, 14, 13, 12],
    ///               [19, 18, 17, 16],
    ///               [23, 22, 21, 20]]]]
    ///               
    ///               # 'dims' is [False, True, False, False]
    ///               reverse(t, dims) ==&amp;gt; [[[[12, 13, 14, 15],
    ///               [16, 17, 18, 19],
    ///               [20, 21, 22, 23]
    ///               [[ 0,  1,  2,  3],
    ///               [ 4,  5,  6,  7],
    ///               [ 8,  9, 10, 11]]]]
    ///               
    ///               # 'dims' is [False, False, True, False]
    ///               reverse(t, dims) ==&amp;gt; [[[[8, 9, 10, 11],
    ///               [4, 5, 6, 7],
    ///               [0, 1, 2, 3]]
    ///               [[20, 21, 22, 23],
    ///               [16, 17, 18, 19],
    ///               [12, 13, 14, 15]]]]
    ///                </code></remarks>
    member this.Reverse(tensor : TF, dims : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Reverse(tensor.TFOutput, dims.TFOutput, operName))
    /// <summary>
    ///               Reverses variable length slices.
    ///             </summary><param name="input">
    ///               The input to reverse.
    ///             </param><param name="seq_lengths">
    ///               1-D with length <c>input.dims(batch_dim)</c> and
    ///               <c>max(seq_lengths) &amp;lt;= input.dims(seq_dim)</c></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReverseSequence'.
    ///             </param><param name="batch_dim">
    ///               Optional argument
    ///               The dimension along which reversal is performed.
    ///             </param><param name="seq_dim">
    ///               The dimension which is partially reversed.
    ///             </param><returns>
    ///               The partially reversed input. It has the same shape as <c>input</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op first slices <c>input</c> along the dimension <c>batch_dim</c>, and for each
    ///               slice <c>i</c>, reverses the first <c>seq_lengths[i]</c> elements along
    ///               the dimension <c>seq_dim</c>.
    ///               
    ///               The elements of <c>seq_lengths</c> must obey <c>seq_lengths[i] &amp;lt;= input.dims[seq_dim]</c>,
    ///               and <c>seq_lengths</c> must be a vector of length <c>input.dims[batch_dim]</c>.
    ///               
    ///               The output slice <c>i</c> along dimension <c>batch_dim</c> is then given by input
    ///               slice <c>i</c>, with the first <c>seq_lengths[i]</c> slices along dimension
    ///               <c>seq_dim</c> reversed.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # Given this:
    ///               batch_dim = 0
    ///               seq_dim = 1
    ///               input.dims = (4, 8, ...)
    ///               seq_lengths = [7, 2, 3, 5]
    ///               
    ///               # then slices of input are reversed on seq_dim, but only up to seq_lengths:
    ///               output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
    ///               output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
    ///               output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
    ///               output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
    ///               
    ///               # while entries past seq_lens are copied through:
    ///               output[0, 7:, :, ...] = input[0, 7:, :, ...]
    ///               output[1, 2:, :, ...] = input[1, 2:, :, ...]
    ///               output[2, 3:, :, ...] = input[2, 3:, :, ...]
    ///               output[3, 2:, :, ...] = input[3, 2:, :, ...]
    ///                </code>
    ///               
    ///               In contrast, if:
    ///               
    ///                <code>
    ///               # Given this:
    ///               batch_dim = 2
    ///               seq_dim = 0
    ///               input.dims = (8, ?, 4, ...)
    ///               seq_lengths = [7, 2, 3, 5]
    ///               
    ///               # then slices of input are reversed on seq_dim, but only up to seq_lengths:
    ///               output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
    ///               output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
    ///               output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
    ///               output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
    ///               
    ///               # while entries past seq_lens are copied through:
    ///               output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
    ///               output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
    ///               output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
    ///               output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
    ///                </code></remarks>
    member this.ReverseSequence(input : TF, seq_lengths : TF, seq_dim : Int64, ?batch_dim : Int64, ?operName : String) =
        let batch_dim = defaultArg (batch_dim |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReverseSequence(input.TFOutput, seq_lengths.TFOutput, seq_dim, batch_dim, operName))
    /// <summary>
    ///               Reverses specific dimensions of a tensor.
    ///             </summary><param name="tensor">
    ///               Up to 8-D.
    ///             </param><param name="axis">
    ///               1-D. The indices of the dimensions to reverse. Must be in the range
    ///               <c>[-rank(tensor), rank(tensor))</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReverseV2'.
    ///             </param><returns>
    ///               The same shape as <c>tensor</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               NOTE <c>tf.reverse</c> has now changed behavior in preparation for 1.0.
    ///               <c>tf.reverse_v2</c> is currently an alias that will be deprecated before TF 1.0.
    ///               
    ///               Given a <c>tensor</c>, and a <c>int32</c> tensor <c>axis</c> representing the set of
    ///               dimensions of <c>tensor</c> to reverse. This operation reverses each dimension
    ///               <c>i</c> for which there exists <c>j</c> s.t. <c>axis[j] == i</c>.
    ///               
    ///               <c>tensor</c> can have up to 8 dimensions. The number of dimensions specified
    ///               in <c>axis</c> may be 0 or more entries. If an index is specified more than
    ///               once, a InvalidArgument error is raised.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor 't' is [[[[ 0,  1,  2,  3],
    ///               #                  [ 4,  5,  6,  7],
    ///               #                  [ 8,  9, 10, 11]],
    ///               #                 [[12, 13, 14, 15],
    ///               #                  [16, 17, 18, 19],
    ///               #                  [20, 21, 22, 23]]]]
    ///               # tensor 't' shape is [1, 2, 3, 4]
    ///               
    ///               # 'dims' is [3] or 'dims' is [-1]
    ///               reverse(t, dims) ==&amp;gt; [[[[ 3,  2,  1,  0],
    ///               [ 7,  6,  5,  4],
    ///               [ 11, 10, 9, 8]],
    ///               [[15, 14, 13, 12],
    ///               [19, 18, 17, 16],
    ///               [23, 22, 21, 20]]]]
    ///               
    ///               # 'dims' is '[1]' (or 'dims' is '[-3]')
    ///               reverse(t, dims) ==&amp;gt; [[[[12, 13, 14, 15],
    ///               [16, 17, 18, 19],
    ///               [20, 21, 22, 23]
    ///               [[ 0,  1,  2,  3],
    ///               [ 4,  5,  6,  7],
    ///               [ 8,  9, 10, 11]]]]
    ///               
    ///               # 'dims' is '[2]' (or 'dims' is '[-2]')
    ///               reverse(t, dims) ==&amp;gt; [[[[8, 9, 10, 11],
    ///               [4, 5, 6, 7],
    ///               [0, 1, 2, 3]]
    ///               [[20, 21, 22, 23],
    ///               [16, 17, 18, 19],
    ///               [12, 13, 14, 15]]]]
    ///                </code></remarks>
    member this.ReverseV2(tensor : TF, axis : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReverseV2(tensor.TFOutput, axis.TFOutput, operName))
    /// <summary>
    ///               Real-valued fast Fourier transform.
    ///             </summary><param name="input">
    ///               A float32 tensor.
    ///             </param><param name="fft_length">
    ///               An int32 tensor of shape [1]. The FFT length.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RFFT'.
    ///             </param><returns>
    ///               A complex64 tensor of the same rank as <c>input</c>. The inner-most
    ///               dimension of <c>input</c> is replaced with the <c>fft_length / 2 + 1</c> unique
    ///               frequency components of its 1D Fourier transform.
    ///               
    ///               @compatibility(numpy)
    ///               Equivalent to np.fft.rfft
    ///               @end_compatibility
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Computes the 1-dimensional discrete Fourier transform of a real-valued signal
    ///               over the inner-most dimension of <c>input</c>.
    ///               
    ///               Since the DFT of a real signal is Hermitian-symmetric, <c>RFFT</c> only returns the
    ///               <c>fft_length / 2 + 1</c> unique components of the FFT: the zero-frequency term,
    ///               followed by the <c>fft_length / 2</c> positive-frequency terms.
    ///               
    ///               Along the axis <c>RFFT</c> is computed on, if <c>fft_length</c> is smaller than the
    ///               corresponding dimension of <c>input</c>, the dimension is cropped. If it is larger,
    ///               the dimension is padded with zeros.
    ///             </remarks>
    member this.RFFT(input : TF, fft_length : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RFFT(input.TFOutput, fft_length.TFOutput, operName))
    /// <summary>
    ///               2D real-valued fast Fourier transform.
    ///             </summary><param name="input">
    ///               A float32 tensor.
    ///             </param><param name="fft_length">
    ///               An int32 tensor of shape [2]. The FFT length for each dimension.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RFFT2D'.
    ///             </param><returns>
    ///               A complex64 tensor of the same rank as <c>input</c>. The inner-most 2
    ///               dimensions of <c>input</c> are replaced with their 2D Fourier transform. The
    ///               inner-most dimension contains <c>fft_length / 2 + 1</c> unique frequency
    ///               components.
    ///               
    ///               @compatibility(numpy)
    ///               Equivalent to np.fft.rfft2
    ///               @end_compatibility
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Computes the 2-dimensional discrete Fourier transform of a real-valued signal
    ///               over the inner-most 2 dimensions of <c>input</c>.
    ///               
    ///               Since the DFT of a real signal is Hermitian-symmetric, <c>RFFT2D</c> only returns the
    ///               <c>fft_length / 2 + 1</c> unique components of the FFT for the inner-most dimension
    ///               of <c>output</c>: the zero-frequency term, followed by the <c>fft_length / 2</c>
    ///               positive-frequency terms.
    ///               
    ///               Along each axis <c>RFFT2D</c> is computed on, if <c>fft_length</c> is smaller than the
    ///               corresponding dimension of <c>input</c>, the dimension is cropped. If it is larger,
    ///               the dimension is padded with zeros.
    ///             </remarks>
    member this.RFFT2D(input : TF, fft_length : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RFFT2D(input.TFOutput, fft_length.TFOutput, operName))
    /// <summary>
    ///               3D real-valued fast Fourier transform.
    ///             </summary><param name="input">
    ///               A float32 tensor.
    ///             </param><param name="fft_length">
    ///               An int32 tensor of shape [3]. The FFT length for each dimension.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RFFT3D'.
    ///             </param><returns>
    ///               A complex64 tensor of the same rank as <c>input</c>. The inner-most 3
    ///               dimensions of <c>input</c> are replaced with the their 3D Fourier transform. The
    ///               inner-most dimension contains <c>fft_length / 2 + 1</c> unique frequency
    ///               components.
    ///               
    ///               @compatibility(numpy)
    ///               Equivalent to np.fft.rfftn with 3 dimensions.
    ///               @end_compatibility
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Computes the 3-dimensional discrete Fourier transform of a real-valued signal
    ///               over the inner-most 3 dimensions of <c>input</c>.
    ///               
    ///               Since the DFT of a real signal is Hermitian-symmetric, <c>RFFT3D</c> only returns the
    ///               <c>fft_length / 2 + 1</c> unique components of the FFT for the inner-most dimension
    ///               of <c>output</c>: the zero-frequency term, followed by the <c>fft_length / 2</c>
    ///               positive-frequency terms.
    ///               
    ///               Along each axis <c>RFFT3D</c> is computed on, if <c>fft_length</c> is smaller than the
    ///               corresponding dimension of <c>input</c>, the dimension is cropped. If it is larger,
    ///               the dimension is padded with zeros.
    ///             </remarks>
    member this.RFFT3D(input : TF, fft_length : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RFFT3D(input.TFOutput, fft_length.TFOutput, operName))
    /// <summary>
    ///               Converts one or more images from RGB to HSV.
    ///             </summary><param name="images">
    ///               1-D or higher rank. RGB data to convert. Last dimension must be size 3.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RGBToHSV'.
    ///             </param><returns><c>images</c> converted to HSV.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Outputs a tensor of the same shape as the <c>images</c> tensor, containing the HSV
    ///               value of the pixels. The output is only well defined if the value in <c>images</c>
    ///               are in <c>[0,1]</c>.
    ///               
    ///               <c>output[..., 0]</c> contains hue, <c>output[..., 1]</c> contains saturation, and
    ///               <c>output[..., 2]</c> contains value. All HSV values are in <c>[0,1]</c>. A hue of 0
    ///               corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
    ///             </remarks>
    member this.RGBToHSV(images : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RGBToHSV(images.TFOutput, operName))
    /// <summary>
    ///               Elementwise computes the bitwise right-shift of <c>x</c> and <c>y</c>.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RightShift'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Performs a logical shift for unsigned integer types, and an arithmetic shift
    ///               for signed integer types.
    ///               
    ///               If <c>y</c> is negative, or greater than or equal to than the width of <c>x</c> in bits
    ///               the result is implementation defined.
    ///             </remarks>
    member this.RightShift(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RightShift(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Returns element-wise integer closest to x.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Rint'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               If the result is midway between two representable values,
    ///               the even representable is chosen.
    ///               For example:
    ///               
    ///                <code>
    ///               rint(-1.5) ==&amp;gt; -2.0
    ///               rint(0.5000001) ==&amp;gt; 1.0
    ///               rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==&amp;gt; [-2., -2., -0., 0., 2., 2., 2.]
    ///                </code></remarks>
    member this.Rint(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Rint(x.TFOutput, operName))
    /// <summary>
    ///               Rolls the elements of a tensor along an axis.
    ///             </summary><param name="input"></param><param name="shift">
    ///               Dimension must be 0-D or 1-D. <c>shift[i]</c> specifies the number of places by which
    ///               elements are shifted positively (towards larger indices) along the dimension
    ///               specified by <c>axis[i]</c>. Negative shifts will roll the elements in the opposite
    ///               direction.
    ///             </param><param name="axis">
    ///               Dimension must be 0-D or 1-D. <c>axis[i]</c> specifies the dimension that the shift
    ///               <c>shift[i]</c> should occur. If the same axis is referenced more than once, the
    ///               total shift for that axis will be the sum of all the shifts that belong to that
    ///               axis.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Roll'.
    ///             </param><returns>
    ///               Has the same shape and size as the input. The elements are shifted
    ///               positively (towards larger indices) by the offsets of <c>shift</c> along the
    ///               dimensions of <c>axis</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The elements are shifted positively (towards larger indices) by the offset of
    ///               <c>shift</c> along the dimension of <c>axis</c>. Negative <c>shift</c> values will shift
    ///               elements in the opposite direction. Elements that roll passed the last position
    ///               will wrap around to the first and vice versa. Multiple shifts along multiple
    ///               axes may be specified.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 't' is [0, 1, 2, 3, 4]
    ///               roll(t, shift=2, axis=0) ==&amp;gt; [3, 4, 0, 1, 2]
    ///               
    ///               # shifting along multiple dimensions
    ///               # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
    ///               roll(t, shift=[1, -2], axis=[0, 1]) ==&amp;gt; [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]]
    ///               
    ///               # shifting along the same axis multiple times
    ///               # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
    ///               roll(t, shift=[2, -3], axis=[1, 1]) ==&amp;gt; [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]
    ///                </code></remarks>
    member this.Roll(input : TF, shift : TF, axis : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Roll(input.TFOutput, shift.TFOutput, axis.TFOutput, operName))
    /// <summary>
    ///               Rounds the values of a tensor to the nearest integer, element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Round'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Rounds half to even.  Also known as bankers rounding. If you want to round
    ///               according to the current system rounding mode use std::cint.
    ///             </remarks>
    member this.Round(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Round(x.TFOutput, operName))
    /// <summary>
    ///               Perform batches of RPC requests.
    ///             </summary><param name="address"><c>0-D</c> or <c>1-D</c>.  The address (i.e. host_name:port) of the RPC server.
    ///               If this tensor has more than 1 element, then multiple parallel rpc requests
    ///               are sent.  This argument broadcasts with <c>method</c> and <c>request</c>.
    ///             </param><param name="method"><c>0-D</c> or <c>1-D</c>.  The method address on the RPC server.
    ///               If this tensor has more than 1 element, then multiple parallel rpc requests
    ///               are sent.  This argument broadcasts with <c>address</c> and <c>request</c>.
    ///             </param><param name="request"><c>0-D</c> or <c>1-D</c>.  Serialized proto strings: the rpc request argument.
    ///               If this tensor has more than 1 element, then multiple parallel rpc requests
    ///               are sent.  This argument broadcasts with <c>address</c> and <c>method</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Rpc'.
    ///             </param><param name="protocol">
    ///               Optional argument
    ///               RPC protocol to use.  Empty string means use the default protocol.
    ///               Options include 'grpc'.
    ///             </param><param name="fail_fast">
    ///               Optional argument
    ///               <c>boolean</c>. If <c>true</c> (default), then failures to connect
    ///               (i.e., the server does not immediately respond) cause an RPC failure.
    ///             </param><param name="timeout_in_ms">
    ///               Optional argument
    ///               <c>int</c>. If <c>0</c> (default), then the kernel will run the RPC
    ///               request and only time out if the RPC deadline passes or the session times out.
    ///               If this value is greater than <c>0</c>, then the op will raise an exception if
    ///               the RPC takes longer than <c>timeout_in_ms</c>.
    ///             </param><returns>
    ///               Same shape as <c>request</c>. Serialized proto strings: the rpc responses.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op asynchronously performs either a single RPC request, or a batch
    ///               of requests.  RPC requests are defined by three main parameters:
    ///               
    ///               - <c>address</c> (the host+port or BNS address of the request)
    ///               - <c>method</c> (the RPC method name for the request)
    ///               - <c>request</c> (the serialized proto string, or vector of strings,
    ///               of the RPC request argument).
    ///               
    ///               For example, if you have an RPC service running on port localhost:2345,
    ///               and its interface is configured with the following proto declaration:
    ///               
    ///                <code>
    ///               service MyService {
    ///               rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
    ///               }
    ///               };
    ///                </code>
    ///               
    ///               then call this op with arguments:
    ///               
    ///                <code>
    ///               address = "localhost:2345"
    ///               method = "MyService/MyMethod"
    ///                </code>
    ///               
    ///               The <c>request</c> tensor is a string tensor representing serialized <c>MyRequestProto</c>
    ///               strings; and the output string tensor <c>response</c> will have the same shape
    ///               and contain (upon successful completion) corresponding serialized
    ///               <c>MyResponseProto</c> strings.
    ///               
    ///               For example, to send a single, empty, <c>MyRequestProto</c>, call
    ///               this op with <c>request = ""</c>.  To send 5 **parallel** empty requests,
    ///               call this op with <c>request = ["", "", "", "", ""]</c>.
    ///               
    ///               More generally, one can create a batch of <c>MyRequestProto</c> serialized protos
    ///               from regular batched tensors using the <c>encode_proto</c> op, and convert
    ///               the response <c>MyResponseProto</c> serialized protos to batched tensors
    ///               using the <c>decode_proto</c> op.
    ///               
    ///               **NOTE** Working with serialized proto strings is faster than instantiating
    ///               actual proto objects in memory, so no performance degradation is expected
    ///               compared to writing custom kernels for this workflow.
    ///               
    ///               If the connection fails or the remote worker returns an error
    ///               status, the op reraises this exception locally.
    ///               
    ///               See the <c>TryRpc</c> op if you prefer to handle RPC failures manually in the graph.
    ///             </remarks>
    member this.Rpc(address : TF, method : TF, request : TF, ?protocol : String, ?fail_fast : Boolean, ?timeout_in_ms : Int64, ?operName : String) =
        let protocol = defaultArg protocol null
        let fail_fast = defaultArg (fail_fast |> Option.map Nullable) (Nullable())
        let timeout_in_ms = defaultArg (timeout_in_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Rpc(address.TFOutput, method.TFOutput, request.TFOutput, protocol, fail_fast, timeout_in_ms, operName))
    /// <summary>
    ///               Computes reciprocal of square root of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Rsqrt'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               I.e., \\(y = 1 / \sqrt{x}\\).
    ///             </remarks>
    member this.Rsqrt(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Rsqrt(x.TFOutput, operName))
    /// <summary>
    ///               Computes the gradient for the rsqrt of <c>x</c> wrt its input.
    ///             </summary><param name="y"></param><param name="dy"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RsqrtGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Specifically, <c>grad = dy * -0.5 * y^3</c>, where <c>y = rsqrt(x)</c>, and <c>dy</c>
    ///               is the corresponding input gradient.
    ///             </remarks>
    member this.RsqrtGrad(y : TF, dy : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RsqrtGrad(y.TFOutput, dy.TFOutput, operName))
    /// <summary>
    ///               Generate a single randomly distorted bounding box for an image.
    ///             </summary><param name="image_size">
    ///               1-D, containing <c>[height, width, channels]</c>.
    ///             </param><param name="bounding_boxes">
    ///               3-D with shape <c>[batch, N, 4]</c> describing the N bounding boxes
    ///               associated with the image.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SampleDistortedBoundingBox'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to non-zero, the random number
    ///               generator is seeded by the given <c>seed</c>.  Otherwise, it is seeded by a random
    ///               seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="min_object_covered">
    ///               Optional argument
    ///               The cropped area of the image must contain at least this
    ///               fraction of any bounding box supplied. The value of this parameter should be
    ///               non-negative. In the case of 0, the cropped area does not need to overlap
    ///               any of the bounding boxes supplied.
    ///             </param><param name="aspect_ratio_range">
    ///               Optional argument
    ///               The cropped area of the image must have an aspect ratio =
    ///               width / height within this range.
    ///             </param><param name="area_range">
    ///               Optional argument
    ///               The cropped area of the image must contain a fraction of the
    ///               supplied image within this range.
    ///             </param><param name="max_attempts">
    ///               Optional argument
    ///               Number of attempts at generating a cropped region of the image
    ///               of the specified constraints. After <c>max_attempts</c> failures, return the entire
    ///               image.
    ///             </param><param name="use_image_if_no_bounding_boxes">
    ///               Optional argument
    ///               Controls behavior if no bounding boxes supplied.
    ///               If true, assume an implicit bounding box covering the whole input. If false,
    ///               raise an error.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               begin: 1-D, containing <c>[offset_height, offset_width, 0]</c>. Provide as input to
    ///               <c>tf.slice</c>.
    ///               size: 1-D, containing <c>[target_height, target_width, -1]</c>. Provide as input to
    ///               <c>tf.slice</c>.
    ///               bboxes: 3-D with shape <c>[1, 1, 4]</c> containing the distorted bounding box.
    ///               Provide as input to <c>tf.image.draw_bounding_boxes</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Bounding box annotations are often supplied in addition to ground-truth labels
    ///               in image recognition or object localization tasks. A common technique for
    ///               training such a system is to randomly distort an image while preserving
    ///               its content, i.e. *data augmentation*. This Op outputs a randomly distorted
    ///               localization of an object, i.e. bounding box, given an <c>image_size</c>,
    ///               <c>bounding_boxes</c> and a series of constraints.
    ///               
    ///               The output of this Op is a single bounding box that may be used to crop the
    ///               original image. The output is returned as 3 tensors: <c>begin</c>, <c>size</c> and
    ///               <c>bboxes</c>. The first 2 tensors can be fed directly into <c>tf.slice</c> to crop the
    ///               image. The latter may be supplied to <c>tf.image.draw_bounding_boxes</c> to visualize
    ///               what the bounding box looks like.
    ///               
    ///               Bounding boxes are supplied and returned as <c>[y_min, x_min, y_max, x_max]</c>. The
    ///               bounding box coordinates are floats in <c>[0.0, 1.0]</c> relative to the width and
    ///               height of the underlying image.
    ///               
    ///               For example,
    ///               
    ///                <code>
    ///               # Generate a single distorted bounding box.
    ///               begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
    ///               tf.shape(image),
    ///               bounding_boxes=bounding_boxes)
    ///               
    ///               # Draw the bounding box in an image summary.
    ///               image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
    ///               bbox_for_draw)
    ///               tf.summary.image('images_with_box', image_with_box)
    ///               
    ///               # Employ the bounding box to distort the image.
    ///               distorted_image = tf.slice(image, begin, size)
    ///                </code>
    ///               
    ///               Note that if no bounding box information is available, setting
    ///               <c>use_image_if_no_bounding_boxes = true</c> will assume there is a single implicit
    ///               bounding box covering the whole image. If <c>use_image_if_no_bounding_boxes</c> is
    ///               false and no bounding boxes are supplied, an error is raised.
    ///             </remarks>
    member this.SampleDistortedBoundingBox(image_size : TF, bounding_boxes : TF, ?seed : Int64, ?seed2 : Int64, ?min_object_covered : Single, ?aspect_ratio_range : Single[], ?area_range : Single[], ?max_attempts : Int64, ?use_image_if_no_bounding_boxes : Boolean, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let min_object_covered = defaultArg (min_object_covered |> Option.map Nullable) (Nullable())
        let aspect_ratio_range = defaultArg aspect_ratio_range null
        let area_range = defaultArg area_range null
        let max_attempts = defaultArg (max_attempts |> Option.map Nullable) (Nullable())
        let use_image_if_no_bounding_boxes = defaultArg (use_image_if_no_bounding_boxes |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SampleDistortedBoundingBox(image_size.TFOutput, bounding_boxes.TFOutput, seed, seed2, min_object_covered, aspect_ratio_range, area_range, max_attempts, use_image_if_no_bounding_boxes, operName)
    /// <summary>
    ///               Generate a single randomly distorted bounding box for an image.
    ///             </summary><param name="image_size">
    ///               1-D, containing <c>[height, width, channels]</c>.
    ///             </param><param name="bounding_boxes">
    ///               3-D with shape <c>[batch, N, 4]</c> describing the N bounding boxes
    ///               associated with the image.
    ///             </param><param name="min_object_covered">
    ///               The cropped area of the image must contain at least this
    ///               fraction of any bounding box supplied. The value of this parameter should be
    ///               non-negative. In the case of 0, the cropped area does not need to overlap
    ///               any of the bounding boxes supplied.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SampleDistortedBoundingBoxV2'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to non-zero, the random number
    ///               generator is seeded by the given <c>seed</c>.  Otherwise, it is seeded by a random
    ///               seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="aspect_ratio_range">
    ///               Optional argument
    ///               The cropped area of the image must have an aspect ratio =
    ///               width / height within this range.
    ///             </param><param name="area_range">
    ///               Optional argument
    ///               The cropped area of the image must contain a fraction of the
    ///               supplied image within this range.
    ///             </param><param name="max_attempts">
    ///               Optional argument
    ///               Number of attempts at generating a cropped region of the image
    ///               of the specified constraints. After <c>max_attempts</c> failures, return the entire
    ///               image.
    ///             </param><param name="use_image_if_no_bounding_boxes">
    ///               Optional argument
    ///               Controls behavior if no bounding boxes supplied.
    ///               If true, assume an implicit bounding box covering the whole input. If false,
    ///               raise an error.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               begin: 1-D, containing <c>[offset_height, offset_width, 0]</c>. Provide as input to
    ///               <c>tf.slice</c>.
    ///               size: 1-D, containing <c>[target_height, target_width, -1]</c>. Provide as input to
    ///               <c>tf.slice</c>.
    ///               bboxes: 3-D with shape <c>[1, 1, 4]</c> containing the distorted bounding box.
    ///               Provide as input to <c>tf.image.draw_bounding_boxes</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Bounding box annotations are often supplied in addition to ground-truth labels
    ///               in image recognition or object localization tasks. A common technique for
    ///               training such a system is to randomly distort an image while preserving
    ///               its content, i.e. *data augmentation*. This Op outputs a randomly distorted
    ///               localization of an object, i.e. bounding box, given an <c>image_size</c>,
    ///               <c>bounding_boxes</c> and a series of constraints.
    ///               
    ///               The output of this Op is a single bounding box that may be used to crop the
    ///               original image. The output is returned as 3 tensors: <c>begin</c>, <c>size</c> and
    ///               <c>bboxes</c>. The first 2 tensors can be fed directly into <c>tf.slice</c> to crop the
    ///               image. The latter may be supplied to <c>tf.image.draw_bounding_boxes</c> to visualize
    ///               what the bounding box looks like.
    ///               
    ///               Bounding boxes are supplied and returned as <c>[y_min, x_min, y_max, x_max]</c>. The
    ///               bounding box coordinates are floats in <c>[0.0, 1.0]</c> relative to the width and
    ///               height of the underlying image.
    ///               
    ///               For example,
    ///               
    ///                <code>
    ///               # Generate a single distorted bounding box.
    ///               begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
    ///               tf.shape(image),
    ///               bounding_boxes=bounding_boxes)
    ///               
    ///               # Draw the bounding box in an image summary.
    ///               image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
    ///               bbox_for_draw)
    ///               tf.summary.image('images_with_box', image_with_box)
    ///               
    ///               # Employ the bounding box to distort the image.
    ///               distorted_image = tf.slice(image, begin, size)
    ///                </code>
    ///               
    ///               Note that if no bounding box information is available, setting
    ///               <c>use_image_if_no_bounding_boxes = true</c> will assume there is a single implicit
    ///               bounding box covering the whole image. If <c>use_image_if_no_bounding_boxes</c> is
    ///               false and no bounding boxes are supplied, an error is raised.
    ///             </remarks>
    member this.SampleDistortedBoundingBoxV2(image_size : TF, bounding_boxes : TF, min_object_covered : TF, ?seed : Int64, ?seed2 : Int64, ?aspect_ratio_range : Single[], ?area_range : Single[], ?max_attempts : Int64, ?use_image_if_no_bounding_boxes : Boolean, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let aspect_ratio_range = defaultArg aspect_ratio_range null
        let area_range = defaultArg area_range null
        let max_attempts = defaultArg (max_attempts |> Option.map Nullable) (Nullable())
        let use_image_if_no_bounding_boxes = defaultArg (use_image_if_no_bounding_boxes |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SampleDistortedBoundingBoxV2(image_size.TFOutput, bounding_boxes.TFOutput, min_object_covered.TFOutput, seed, seed2, aspect_ratio_range, area_range, max_attempts, use_image_if_no_bounding_boxes, operName)
    /// <summary>
    ///               Saves the input tensors to disk.
    ///             </summary><param name="filename">
    ///               Must have a single element. The name of the file to which we write
    ///               the tensor.
    ///             </param><param name="tensor_names">
    ///               Shape <c>[N]</c>. The names of the tensors to be saved.
    ///             </param><param name="data"><c>N</c> tensors to save.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Save'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The size of <c>tensor_names</c> must match the number of tensors in <c>data</c>. <c>data[i]</c>
    ///               is written to <c>filename</c> with name <c>tensor_names[i]</c>.
    ///               
    ///               See also <c>SaveSlices</c>.
    ///             </remarks>
    member this.Save(filename : TF, tensor_names : TF, data : TF[], ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.Save(filename.TFOutput, tensor_names.TFOutput, data |> Array.map (fun x -> x.TFOutput), operName)
    /// <summary>
    ///               Saves input tensors slices to disk.
    ///             </summary><param name="filename">
    ///               Must have a single element. The name of the file to which we write the
    ///               tensor.
    ///             </param><param name="tensor_names">
    ///               Shape <c>[N]</c>. The names of the tensors to be saved.
    ///             </param><param name="shapes_and_slices">
    ///               Shape <c>[N]</c>.  The shapes and slice specifications to use when
    ///               saving the tensors.
    ///             </param><param name="data"><c>N</c> tensors to save.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SaveSlices'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This is like <c>Save</c> except that tensors can be listed in the saved file as being
    ///               a slice of a larger tensor.  <c>shapes_and_slices</c> specifies the shape of the
    ///               larger tensor and the slice that this tensor covers. <c>shapes_and_slices</c> must
    ///               have as many elements as <c>tensor_names</c>.
    ///               
    ///               Elements of the <c>shapes_and_slices</c> input must either be:
    ///               
    ///               *  The empty string, in which case the corresponding tensor is
    ///               saved normally.
    ///               *  A string of the form <c>dim0 dim1 ... dimN-1 slice-spec</c> where the
    ///               <c>dimI</c> are the dimensions of the larger tensor and <c>slice-spec</c>
    ///               specifies what part is covered by the tensor to save.
    ///               
    ///               <c>slice-spec</c> itself is a <c>:</c>-separated list: <c>slice0:slice1:...:sliceN-1</c>
    ///               where each <c>sliceI</c> is either:
    ///               
    ///               *  The string <c>-</c> meaning that the slice covers all indices of this dimension
    ///               *  <c>start,length</c> where <c>start</c> and <c>length</c> are integers.  In that
    ///               case the slice covers <c>length</c> indices starting at <c>start</c>.
    ///               
    ///               See also <c>Save</c>.
    ///             </remarks>
    member this.SaveSlices(filename : TF, tensor_names : TF, shapes_and_slices : TF, data : TF[], ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SaveSlices(filename.TFOutput, tensor_names.TFOutput, shapes_and_slices.TFOutput, data |> Array.map (fun x -> x.TFOutput), operName)
    /// <summary>
    ///               Saves tensors in V2 checkpoint format.
    ///             </summary><param name="prefix">
    ///               Must have a single element. The prefix of the V2 checkpoint to which we
    ///               write the tensors.
    ///             </param><param name="tensor_names">
    ///               shape {N}. The names of the tensors to be saved.
    ///             </param><param name="shape_and_slices">
    ///               shape {N}.  The slice specs of the tensors to be saved.
    ///               Empty strings indicate that they are non-partitioned tensors.
    ///             </param><param name="tensors"><c>N</c> tensors to save.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SaveV2'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               By default, saves the named tensors in full.  If the caller wishes to save
    ///               specific slices of full tensors, "shape_and_slices" should be non-empty strings
    ///               and correspondingly well-formed.
    ///             </remarks>
    member this.SaveV2(prefix : TF, tensor_names : TF, shape_and_slices : TF, tensors : TF[], ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SaveV2(prefix.TFOutput, tensor_names.TFOutput, shape_and_slices.TFOutput, tensors |> Array.map (fun x -> x.TFOutput), operName)
    member this.ScalarSummary(tags : TF, values : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScalarSummary(tags.TFOutput, values.TFOutput, operName))
    /// <summary>
    ///               Adds sparse updates to a variable reference.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterAdd'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the addition will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] += updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] += updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions add.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterAdd.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ScatterAdd(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterAdd(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Divides a variable reference by sparse updates.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of values that <c>ref</c> is divided by.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterDiv'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the operation will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///                <code>
    ///               # Scalar indices
    ///               ref[indices, ...] /= updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] /= updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
    ///                </code>
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions divide.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///             </remarks>
    member this.ScatterDiv(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterDiv(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Reduces sparse updates into a variable reference using the <c>max</c> operation.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to reduce into <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterMax'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the update will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] = max(ref[indices, ...], updates[...])
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions combine.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterAdd.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ScatterMax(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterMax(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Reduces sparse updates into a variable reference using the <c>min</c> operation.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to reduce into <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterMin'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the update will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] = min(ref[indices, ...], updates[...])
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions combine.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterAdd.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ScatterMin(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterMin(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Multiplies sparse updates into a variable reference.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to multiply to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterMul'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the operation will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///                <code>
    ///               # Scalar indices
    ///               ref[indices, ...] *= updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] *= updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
    ///                </code>
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions multiply.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///             </remarks>
    member this.ScatterMul(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterMul(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Scatter <c>updates</c> into a new tensor according to <c>indices</c>.
    ///             </summary><param name="indices">
    ///               Index tensor.
    ///             </param><param name="updates">
    ///               Updates to scatter into output.
    ///             </param><param name="shape">
    ///               1-D. The shape of the resulting tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterNd'.
    ///             </param><returns>
    ///               A new tensor with the given shape and updates applied according
    ///               to the indices.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Creates a new tensor by applying sparse <c>updates</c> to individual values or
    ///               slices within a tensor (initially zero for numeric, empty for string) of
    ///               the given <c>shape</c> according to indices.  This operator is the inverse of the
    ///               <c>tf.gather_nd</c> operator which extracts values or slices from a given tensor.
    ///               
    ///               This operation is similar to tensor_scatter_add, except that the tensor is
    ///               zero-initialized. Calling <c>tf.scatter_nd(indices, values, shape)</c> is identical
    ///               to <c>tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)</c>
    ///               
    ///               If <c>indices</c> contains duplicates, then their updates are accumulated (summed).
    ///               
    ///               **WARNING**: The order in which updates are applied is nondeterministic, so the
    ///               output will be nondeterministic if <c>indices</c> contains duplicates -- because
    ///               of some numerical approximation issues, numbers summed in different order
    ///               may yield different results.
    ///               
    ///               <c>indices</c> is an integer tensor containing indices into a new tensor of shape
    ///               <c>shape</c>.  The last dimension of <c>indices</c> can be at most the rank of <c>shape</c>:
    ///               
    ///               indices.shape[-1] &amp;lt;= shape.rank
    ///               
    ///               The last dimension of <c>indices</c> corresponds to indices into elements
    ///               (if <c>indices.shape[-1] = shape.rank</c>) or slices
    ///               (if <c>indices.shape[-1] &amp;lt; shape.rank</c>) along dimension <c>indices.shape[-1]</c> of
    ///               <c>shape</c>.  <c>updates</c> is a tensor with shape
    ///               
    ///               indices.shape[:-1] + shape[indices.shape[-1]:]
    ///               
    ///               The simplest form of scatter is to insert individual elements in a tensor by
    ///               index. For example, say we want to insert 4 scattered elements in a rank-1
    ///               tensor with 8 elements.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///               
    ///               In Python, this scatter operation would look like this:
    ///               
    ///                <code>
    ///               indices = tf.constant([[4], [3], [1], [7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               shape = tf.constant([8])
    ///               scatter = tf.scatter_nd(indices, updates, shape)
    ///               with tf.Session() as sess:
    ///               print(sess.run(scatter))
    ///                </code>
    ///               
    ///               The resulting tensor would look like this:
    ///               
    ///               [0, 11, 0, 10, 9, 0, 0, 12]
    ///               
    ///               We can also, insert entire slices of a higher rank tensor all at once. For
    ///               example, if we wanted to insert two slices in the first dimension of a
    ///               rank-3 tensor with two matrices of new values.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd2.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///               
    ///               In Python, this scatter operation would look like this:
    ///               
    ///                <code>
    ///               indices = tf.constant([[0], [2]])
    ///               updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
    ///               [7, 7, 7, 7], [8, 8, 8, 8]],
    ///               [[5, 5, 5, 5], [6, 6, 6, 6],
    ///               [7, 7, 7, 7], [8, 8, 8, 8]]])
    ///               shape = tf.constant([4, 4, 4])
    ///               scatter = tf.scatter_nd(indices, updates, shape)
    ///               with tf.Session() as sess:
    ///               print(sess.run(scatter))
    ///                </code>
    ///               
    ///               The resulting tensor would look like this:
    ///               
    ///               [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
    ///               [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
    ///               [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
    ///               [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
    ///               
    ///               Note that on CPU, if an out of bound index is found, an error is returned.
    ///               On GPU, if an out of bound index is found, the index is ignored.
    ///             </remarks>
    member this.ScatterNd(indices : TF, updates : TF, shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterNd(indices.TFOutput, updates.TFOutput, shape.TFOutput, operName))
    /// <summary>
    ///               Applies sparse addition between <c>updates</c> and individual values or slices
    ///             </summary><param name="reference">
    ///               A mutable Tensor. Should be from a Variable node.
    ///             </param><param name="indices">
    ///               A Tensor. Must be one of the following types: int32, int64.
    ///               A tensor of indices into ref.
    ///             </param><param name="updates">
    ///               A Tensor. Must have the same type as ref. A tensor of updated values
    ///               to add to ref.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterNdAdd'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               An optional bool. Defaults to True. If True, the assignment will
    ///               be protected by a lock; otherwise the behavior is undefined,
    ///               but may exhibit less contention.
    ///             </param><returns>
    ///               Same as ref. Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               within a given variable according to <c>indices</c>.
    ///               
    ///               <c>ref</c> is a <c>Tensor</c> with rank <c>P</c> and <c>indices</c> is a <c>Tensor</c> of rank <c>Q</c>.
    ///               
    ///               <c>indices</c> must be integer tensor, containing indices into <c>ref</c>.
    ///               It must be shape <c>\\([d_0, ..., d_{Q-2}, K]\\)</c> where <c>0 &amp;lt; K &amp;lt;= P</c>.
    ///               
    ///               The innermost dimension of <c>indices</c> (with length <c>K</c>) corresponds to
    ///               indices into elements (if <c>K = P</c>) or slices (if <c>K &amp;lt; P</c>) along the <c>K</c>th
    ///               dimension of <c>ref</c>.
    ///               
    ///               <c>updates</c> is <c>Tensor</c> of rank <c>Q-1+P-K</c> with shape:
    ///               
    ///               $$[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].$$
    ///               
    ///               For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
    ///               elements. In Python, that addition would look like this:
    ///               
    ///               ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    ///               indices = tf.constant([[4], [3], [1], [7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               add = tf.scatter_nd_add(ref, indices, updates)
    ///               with tf.Session() as sess:
    ///               print sess.run(add)
    ///               
    ///               The resulting update to ref would look like this:
    ///               
    ///               [1, 13, 3, 14, 14, 6, 7, 20]
    ///               
    ///               See <c>tf.scatter_nd</c> for more details about how to make updates to
    ///               slices.
    ///             </remarks>
    member this.ScatterNdAdd(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterNdAdd(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Applies sparse addition to <c>input</c> using individual values or slices
    ///             </summary><param name="input">
    ///               A Tensor.
    ///             </param><param name="indices">
    ///               A Tensor. Must be one of the following types: <c>int32</c>, <c>int64</c>.
    ///               A tensor of indices into <c>input</c>.
    ///             </param><param name="updates">
    ///               A Tensor. Must have the same type as ref. A tensor of updated values
    ///               to add to <c>input</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterNdNonAliasingAdd'.
    ///             </param><returns>
    ///               A <c>Tensor</c> with the same shape as <c>input</c>, containing values of <c>input</c>
    ///               updated with <c>updates</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               from <c>updates</c> according to indices <c>indices</c>.  The updates are non-aliasing:
    ///               <c>input</c> is only modified in-place if no other operations will use it.
    ///               Otherwise, a copy of <c>input</c> is made.  This operation has a gradient with
    ///               respect to both <c>input</c> and <c>updates</c>.
    ///               
    ///               <c>input</c> is a <c>Tensor</c> with rank <c>P</c> and <c>indices</c> is a <c>Tensor</c> of rank <c>Q</c>.
    ///               
    ///               <c>indices</c> must be integer tensor, containing indices into <c>input</c>.
    ///               It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where <c>0 &amp;lt; K &amp;lt;= P</c>.
    ///               
    ///               The innermost dimension of <c>indices</c> (with length <c>K</c>) corresponds to
    ///               indices into elements (if <c>K = P</c>) or <c>(P-K)</c>-dimensional slices
    ///               (if <c>K &amp;lt; P</c>) along the <c>K</c>th dimension of <c>input</c>.
    ///               
    ///               <c>updates</c> is <c>Tensor</c> of rank <c>Q-1+P-K</c> with shape:
    ///               
    ///               $$[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].$$
    ///               
    ///               For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
    ///               elements. In Python, that addition would look like this:
    ///               
    ///               input = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
    ///               indices = tf.constant([[4], [3], [1], [7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
    ///               with tf.Session() as sess:
    ///               print(sess.run(output))
    ///               
    ///               The resulting value <c>output</c> would look like this:
    ///               
    ///               [1, 13, 3, 14, 14, 6, 7, 20]
    ///               
    ///               See <c>tf.scatter_nd</c> for more details about how to make updates to slices.
    ///             </remarks>
    member this.ScatterNdNonAliasingAdd(input : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterNdNonAliasingAdd(input.TFOutput, indices.TFOutput, updates.TFOutput, operName))
    /// <summary>
    ///               Applies sparse subtraction between <c>updates</c> and individual values or slices
    ///             </summary><param name="reference">
    ///               A mutable Tensor. Should be from a Variable node.
    ///             </param><param name="indices">
    ///               A Tensor. Must be one of the following types: int32, int64.
    ///               A tensor of indices into ref.
    ///             </param><param name="updates">
    ///               A Tensor. Must have the same type as ref. A tensor of updated values
    ///               to subtract from ref.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterNdSub'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               An optional bool. Defaults to True. If True, the assignment will
    ///               be protected by a lock; otherwise the behavior is undefined,
    ///               but may exhibit less contention.
    ///             </param><returns>
    ///               Same as ref. Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               within a given variable according to <c>indices</c>.
    ///               
    ///               <c>ref</c> is a <c>Tensor</c> with rank <c>P</c> and <c>indices</c> is a <c>Tensor</c> of rank <c>Q</c>.
    ///               
    ///               <c>indices</c> must be integer tensor, containing indices into <c>ref</c>.
    ///               It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where <c>0 &amp;lt; K &amp;lt;= P</c>.
    ///               
    ///               The innermost dimension of <c>indices</c> (with length <c>K</c>) corresponds to
    ///               indices into elements (if <c>K = P</c>) or slices (if <c>K &amp;lt; P</c>) along the <c>K</c>th
    ///               dimension of <c>ref</c>.
    ///               
    ///               <c>updates</c> is <c>Tensor</c> of rank <c>Q-1+P-K</c> with shape:
    ///               
    ///               $$[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].$$
    ///               
    ///               For example, say we want to subtract 4 scattered elements from a rank-1 tensor
    ///               with 8 elements. In Python, that subtraction would look like this:
    ///               
    ///               ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    ///               indices = tf.constant([[4], [3], [1], [7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               sub = tf.scatter_nd_sub(ref, indices, updates)
    ///               with tf.Session() as sess:
    ///               print sess.run(sub)
    ///               
    ///               The resulting update to ref would look like this:
    ///               
    ///               [1, -9, 3, -6, -4, 6, 7, -4]
    ///               
    ///               See <c>tf.scatter_nd</c> for more details about how to make updates to
    ///               slices.
    ///             </remarks>
    member this.ScatterNdSub(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterNdSub(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Applies sparse <c>updates</c> to individual values or slices within a given
    ///             </summary><param name="reference">
    ///               A mutable Tensor. Should be from a Variable node.
    ///             </param><param name="indices">
    ///               A Tensor. Must be one of the following types: int32, int64.
    ///               A tensor of indices into ref.
    ///             </param><param name="updates">
    ///               A Tensor. Must have the same type as ref. A tensor of updated
    ///               values to add to ref.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterNdUpdate'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               An optional bool. Defaults to True. If True, the assignment will
    ///               be protected by a lock; otherwise the behavior is undefined,
    ///               but may exhibit less contention.
    ///             </param><returns>
    ///               Same as ref. Returned as a convenience for operations that want to
    ///               use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               variable according to <c>indices</c>.
    ///               
    ///               <c>ref</c> is a <c>Tensor</c> with rank <c>P</c> and <c>indices</c> is a <c>Tensor</c> of rank <c>Q</c>.
    ///               
    ///               <c>indices</c> must be integer tensor, containing indices into <c>ref</c>.
    ///               It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where <c>0 &amp;lt; K &amp;lt;= P</c>.
    ///               
    ///               The innermost dimension of <c>indices</c> (with length <c>K</c>) corresponds to
    ///               indices into elements (if <c>K = P</c>) or slices (if <c>K &amp;lt; P</c>) along the <c>K</c>th
    ///               dimension of <c>ref</c>.
    ///               
    ///               <c>updates</c> is <c>Tensor</c> of rank <c>Q-1+P-K</c> with shape:
    ///               
    ///               $$[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].$$
    ///               
    ///               For example, say we want to update 4 scattered elements to a rank-1 tensor to
    ///               8 elements. In Python, that update would look like this:
    ///               
    ///                <code>
    ///               ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    ///               indices = tf.constant([[4], [3], [1] ,[7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               update = tf.scatter_nd_update(ref, indices, updates)
    ///               with tf.Session() as sess:
    ///               print sess.run(update)
    ///                </code>
    ///               
    ///               The resulting update to ref would look like this:
    ///               
    ///               [1, 11, 3, 10, 9, 6, 7, 12]
    ///               
    ///               See <c>tf.scatter_nd</c> for more details about how to make updates to
    ///               slices.
    ///               
    ///               See also <c>tf.scatter_update</c> and <c>tf.batch_scatter_update</c>.
    ///             </remarks>
    member this.ScatterNdUpdate(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterNdUpdate(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Subtracts sparse updates to a variable reference.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to subtract from <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterSub'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the subtraction will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks><code>
    ///               # Scalar indices
    ///               ref[indices, ...] -= updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] -= updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
    ///                </code>
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their (negated) contributions add.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterSub.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ScatterSub(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterSub(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Applies sparse updates to a variable reference.
    ///             </summary><param name="reference">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to store in <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ScatterUpdate'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the assignment will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               = Same as <c>ref</c>.  Returned as a convenience for operations that want
    ///               to use the updated values after the update is done.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///                <code>
    ///               # Scalar indices
    ///               ref[indices, ...] = updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] = updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
    ///                </code>
    ///               
    ///               This operation outputs <c>ref</c> after the update is done.
    ///               This makes it easier to chain operations that need to use the reset value.
    ///               
    ///               If values in <c>ref</c> is to be updated more than once, because there are
    ///               duplicate entries in <c>indices</c>, the order at which the updates happen
    ///               for each value is undefined.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/ScatterUpdate.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///               
    ///               See also <c>tf.batch_scatter_update</c> and <c>tf.scatter_nd_update</c>.
    ///             </remarks>
    member this.ScatterUpdate(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ScatterUpdate(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName))
    /// <summary>
    ///               Computes fingerprints of the input strings.
    ///             </summary><param name="input">
    ///               vector of strings to compute fingerprints on.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SdcaFprint'.
    ///             </param><returns>
    ///               a (N,2) shaped matrix where N is the number of elements in the input
    ///               vector. Each row contains the low and high parts of the fingerprint.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SdcaFprint(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SdcaFprint(input.TFOutput, operName))
    /// <summary>
    ///               Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
    ///             </summary><param name="sparse_example_indices">
    ///               a list of vectors which contain example indices.
    ///             </param><param name="sparse_feature_indices">
    ///               a list of vectors which contain feature indices.
    ///             </param><param name="sparse_feature_values">
    ///               a list of vectors which contains feature value
    ///               associated with each feature group.
    ///             </param><param name="dense_features">
    ///               a list of matrices which contains the dense feature values.
    ///             </param><param name="example_weights">
    ///               a vector which contains the weight associated with each
    ///               example.
    ///             </param><param name="example_labels">
    ///               a vector which contains the label/target associated with each
    ///               example.
    ///             </param><param name="sparse_indices">
    ///               a list of vectors where each value is the indices which has
    ///               corresponding weights in sparse_weights. This field maybe omitted for the
    ///               dense approach.
    ///             </param><param name="sparse_weights">
    ///               a list of vectors where each value is the weight associated with
    ///               a sparse feature group.
    ///             </param><param name="dense_weights">
    ///               a list of vectors where the values are the weights associated
    ///               with a dense feature group.
    ///             </param><param name="example_state_data">
    ///               a list of vectors containing the example state data.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SdcaOptimizer'.
    ///             </param><param name="adaptative">
    ///               Optional argument
    ///               Whether to use Adaptive SDCA for the inner loop.
    ///             </param><param name="loss_type">
    ///               Type of the primal loss. Currently SdcaSolver supports logistic,
    ///               squared and hinge losses.
    ///             </param><param name="l1">
    ///               Symmetric l1 regularization strength.
    ///             </param><param name="l2">
    ///               Symmetric l2 regularization strength.
    ///             </param><param name="num_loss_partitions">
    ///               Number of partitions of the global loss function.
    ///             </param><param name="num_inner_iterations">
    ///               Number of iterations per mini-batch.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               out_example_state_data: a list of vectors containing the updated example state
    ///               data.
    ///               out_delta_sparse_weights: a list of vectors where each value is the delta
    ///               weights associated with a sparse feature group.
    ///               out_delta_dense_weights: a list of vectors where the values are the delta
    ///               weights associated with a dense feature group.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               linear models with L1 + L2 regularization. As global optimization objective is
    ///               strongly-convex, the optimizer optimizes the dual objective at each step. The
    ///               optimizer applies each update one example at a time. Examples are sampled
    ///               uniformly, and the optimizer is learning rate free and enjoys linear convergence
    ///               rate.
    ///               
    ///               [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).&amp;lt;br&amp;gt;
    ///               Shai Shalev-Shwartz, Tong Zhang. 2012
    ///               
    ///               $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
    ///               
    ///               [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).&amp;lt;br&amp;gt;
    ///               Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
    ///               Peter Richtarik, Martin Takac. 2015
    ///               
    ///               [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).&amp;lt;br&amp;gt;
    ///               Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
    ///             </remarks>
    member this.SdcaOptimizer(sparse_example_indices : TF[], sparse_feature_indices : TF[], sparse_feature_values : TF[], dense_features : TF[], example_weights : TF, example_labels : TF, sparse_indices : TF[], sparse_weights : TF[], dense_weights : TF[], example_state_data : TF, loss_type : String, l1 : Single, l2 : Single, num_loss_partitions : Int64, num_inner_iterations : Int64, ?adaptative : Boolean, ?operName : String) =
        let adaptative = defaultArg (adaptative |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SdcaOptimizer(sparse_example_indices |> Array.map (fun x -> x.TFOutput), sparse_feature_indices |> Array.map (fun x -> x.TFOutput), sparse_feature_values |> Array.map (fun x -> x.TFOutput), dense_features |> Array.map (fun x -> x.TFOutput), example_weights.TFOutput, example_labels.TFOutput, sparse_indices |> Array.map (fun x -> x.TFOutput), sparse_weights |> Array.map (fun x -> x.TFOutput), dense_weights |> Array.map (fun x -> x.TFOutput), example_state_data.TFOutput, loss_type, l1, l2, num_loss_partitions, num_inner_iterations, adaptative, operName)
    /// <summary>
    ///               Applies L1 regularization shrink step on the parameters.
    ///             </summary><param name="weights">
    ///               a list of vectors where each value is the weight associated with a
    ///               feature group.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SdcaShrinkL1'.
    ///             </param><param name="l1">
    ///               Symmetric l1 regularization strength.
    ///             </param><param name="l2">
    ///               Symmetric l2 regularization strength. Should be a positive float.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.SdcaShrinkL1(weights : TF[], l1 : Single, l2 : Single, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SdcaShrinkL1(weights |> Array.map (fun x -> x.TFOutput), l1, l2, operName)
    /// <summary>
    ///               Computes the maximum along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A 1-D tensor whose size is equal to the size of <c>data</c>'s
    ///               first dimension.  Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SegmentMax'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Computes a tensor such that
    ///               \\(output_i = \max_j(data_j)\\) where <c>max</c> is over <c>j</c> such
    ///               that <c>segment_ids[j] == i</c>.
    ///               
    ///               If the max is empty for a given segment ID <c>i</c>, <c>output[i] = 0</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/SegmentMax.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.SegmentMax(data : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SegmentMax(data.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes the mean along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A 1-D tensor whose size is equal to the size of <c>data</c>'s
    ///               first dimension.  Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SegmentMean'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Computes a tensor such that
    ///               \\(output_i = \frac{\sum_j data_j}{N}\\) where <c>mean</c> is
    ///               over <c>j</c> such that <c>segment_ids[j] == i</c> and <c>N</c> is the total number of
    ///               values summed.
    ///               
    ///               If the mean is empty for a given segment ID <c>i</c>, <c>output[i] = 0</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/SegmentMean.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.SegmentMean(data : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SegmentMean(data.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes the minimum along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A 1-D tensor whose size is equal to the size of <c>data</c>'s
    ///               first dimension.  Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SegmentMin'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Computes a tensor such that
    ///               \\(output_i = \min_j(data_j)\\) where <c>min</c> is over <c>j</c> such
    ///               that <c>segment_ids[j] == i</c>.
    ///               
    ///               If the min is empty for a given segment ID <c>i</c>, <c>output[i] = 0</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/SegmentMin.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.SegmentMin(data : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SegmentMin(data.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes the product along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A 1-D tensor whose size is equal to the size of <c>data</c>'s
    ///               first dimension.  Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SegmentProd'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Computes a tensor such that
    ///               \\(output_i = \prod_j data_j\\) where the product is over <c>j</c> such
    ///               that <c>segment_ids[j] == i</c>.
    ///               
    ///               If the product is empty for a given segment ID <c>i</c>, <c>output[i] = 1</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/SegmentProd.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.SegmentProd(data : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SegmentProd(data.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Computes the sum along segments of a tensor.
    ///             </summary><param name="data"></param><param name="segment_ids">
    ///               A 1-D tensor whose size is equal to the size of <c>data</c>'s
    ///               first dimension.  Values should be sorted and can be repeated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SegmentSum'.
    ///             </param><returns>
    ///               Has same shape as data, except for dimension 0 which
    ///               has size <c>k</c>, the number of segments.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Read
    ///               [the section on segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)
    ///               for an explanation of segments.
    ///               
    ///               Computes a tensor such that
    ///               \\(output_i = \sum_j data_j\\) where sum is over <c>j</c> such
    ///               that <c>segment_ids[j] == i</c>.
    ///               
    ///               If the sum is empty for a given segment ID <c>i</c>, <c>output[i] = 0</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src="https://www.tensorflow.org/images/SegmentSum.png" alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.SegmentSum(data : TF, segment_ids : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SegmentSum(data.TFOutput, segment_ids.TFOutput, operName))
    /// <summary>
    ///               Selects elements from <c>x</c> or <c>y</c>, depending on <c>condition</c>.
    ///             </summary><param name="condition"></param><param name="t">
    ///               = A <c>Tensor</c> which may have the same shape as <c>condition</c>.
    ///               If <c>condition</c> is rank 1, <c>x</c> may have higher rank,
    ///               but its first dimension must match the size of <c>condition</c>.
    ///             </param><param name="e">
    ///               = A <c>Tensor</c> with the same type and shape as <c>x</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Select'.
    ///             </param><returns>
    ///               = A <c>Tensor</c> with the same type and shape as <c>x</c> and <c>y</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The <c>x</c>, and <c>y</c> tensors must all have the same shape, and the
    ///               output will also have that shape.
    ///               
    ///               The <c>condition</c> tensor must be a scalar if <c>x</c> and <c>y</c> are scalars.
    ///               If <c>x</c> and <c>y</c> are vectors or higher rank, then <c>condition</c> must be either a
    ///               scalar, a vector with size matching the first dimension of <c>x</c>, or must have
    ///               the same shape as <c>x</c>.
    ///               
    ///               The <c>condition</c> tensor acts as a mask that chooses, based on the value at each
    ///               element, whether the corresponding element / row in the output should be
    ///               taken from <c>x</c> (if true) or <c>y</c> (if false).
    ///               
    ///               If <c>condition</c> is a vector and <c>x</c> and <c>y</c> are higher rank matrices, then
    ///               it chooses which row (outer dimension) to copy from <c>x</c> and <c>y</c>.
    ///               If <c>condition</c> has the same shape as <c>x</c> and <c>y</c>, then it chooses which
    ///               element to copy from <c>x</c> and <c>y</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 'condition' tensor is [[True,  False]
    ///               #                        [False, True]]
    ///               # 't' is [[1, 2],
    ///               #         [3, 4]]
    ///               # 'e' is [[5, 6],
    ///               #         [7, 8]]
    ///               select(condition, t, e)  # =&amp;gt; [[1, 6], [7, 4]]
    ///               
    ///               
    ///               # 'condition' tensor is [True, False]
    ///               # 't' is [[1, 2],
    ///               #         [3, 4]]
    ///               # 'e' is [[5, 6],
    ///               #         [7, 8]]
    ///               select(condition, t, e) ==&amp;gt; [[1, 2],
    ///               [7, 8]]
    ///               
    ///                </code></remarks>
    member this.Select(condition : TF, t : TF, e : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Select(condition.TFOutput, t.TFOutput, e.TFOutput, operName))
    /// <summary>
    ///               Computes the Eigen Decomposition of a batch of square self-adjoint matrices.
    ///             </summary><param name="input">
    ///               Shape is <c>[..., M, M]</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SelfAdjointEig'.
    ///             </param><returns>
    ///               Shape is <c>[..., M+1, M]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The input is a tensor of shape <c>[..., M, M]</c> whose inner-most 2 dimensions
    ///               form square matrices, with the same constraints as the single matrix
    ///               SelfAdjointEig.
    ///               
    ///               The result is a [..., M+1, M] matrix with [..., 0,:] containing the
    ///               eigenvalues, and subsequent [...,1:, :] containing the eigenvectors. The eigenvalues
    ///               are sorted in non-decreasing order.
    ///             </remarks>
    member this.SelfAdjointEig(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SelfAdjointEig(input.TFOutput, operName))
    /// <summary>
    ///               Computes the eigen decomposition of one or more square self-adjoint matrices.
    ///             </summary><param name="input"><c>Tensor</c> input of shape <c>[N, N]</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SelfAdjointEigV2'.
    ///             </param><param name="compute_v">
    ///               Optional argument
    ///               If <c>True</c> then eigenvectors will be computed and returned in <c>v</c>.
    ///               Otherwise, only the eigenvalues will be computed.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               e: Eigenvalues. Shape is <c>[N]</c>.
    ///               v: Eigenvectors. Shape is <c>[N, N]</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
    ///               <c>input</c> such that <c>input[..., :, :] = v[..., :, :] * diag(e[..., :])</c>. The eigenvalues
    ///               are sorted in non-decreasing order.
    ///               
    ///                <code>
    ///               # a is a tensor.
    ///               # e is a tensor of eigenvalues.
    ///               # v is a tensor of eigenvectors.
    ///               e, v = self_adjoint_eig(a)
    ///               e = self_adjoint_eig(a, compute_v=False)
    ///                </code></remarks>
    member this.SelfAdjointEigV2(input : TF, ?compute_v : Boolean, ?operName : String) =
        let compute_v = defaultArg (compute_v |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SelfAdjointEigV2(input.TFOutput, compute_v, operName)
    /// <summary>
    ///               Computes scaled exponential linear: <c>scale * alpha * (exp(features) - 1)</c></summary><param name="features"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Selu'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               if &amp;lt; 0, <c>scale * features</c> otherwise.
    ///               
    ///               To be used together with
    ///               <c>initializer = tf.variance_scaling_initializer(factor=1.0, mode='FAN_IN')</c>.
    ///               For correct dropout, use <c>tf.contrib.nn.alpha_dropout</c>.
    ///               
    ///               See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
    ///             </remarks>
    member this.Selu(features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Selu(features.TFOutput, operName))
    /// <summary>
    ///               Computes gradients for the scaled exponential linear (Selu) operation.
    ///             </summary><param name="gradients">
    ///               The backpropagated gradients to the corresponding Selu operation.
    ///             </param><param name="outputs">
    ///               The outputs of the corresponding Selu operation.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SeluGrad'.
    ///             </param><returns>
    ///               The gradients: <c>gradients * (outputs + scale * alpha)</c>
    ///               if outputs &amp;lt; 0, <c>scale * gradients</c> otherwise.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SeluGrad(gradients : TF, outputs : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SeluGrad(gradients.TFOutput, outputs.TFOutput, operName))
    /// <summary>
    ///               An op that performs gradient updates of embedding tables.
    ///             </summary><param name="inputs">
    ///               A TensorList of gradients with which to update embedding tables.
    ///               It contains one tensor per embedding table in the model.
    ///             </param><param name="learning_rates">
    ///               A list of float32 scalars, one for each embedding table,
    ///               containing the learning rates for each table when dynamic learning rate is
    ///               enabled through the OptimizationParameters in TPUEmbeddingConfiguration.
    ///               When the learning rate is constant, the list should be empty.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SendTPUEmbeddingGradients'.
    ///             </param><param name="config">
    ///               Serialized TPUEmbeddingConfiguration proto.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The TensorList argument has the same length and shapes as the return value of
    ///               TPUEmbeddingReceiveActivations, but contains gradients of the model's loss
    ///               with respect to the embedding activations. The embedding tables are updated
    ///               from these gradients via the optimizer specified in the configuration given
    ///               to tpu.initialize_system.
    ///             </remarks>
    member this.SendTPUEmbeddingGradients(inputs : TF[], learning_rates : TF[], config : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SendTPUEmbeddingGradients(inputs |> Array.map (fun x -> x.TFOutput), learning_rates |> Array.map (fun x -> x.TFOutput), config, operName)
    /// <summary>
    ///               Converts the given <c>resource_handle</c> representing an iterator to a variant tensor.
    ///             </summary><param name="resource_handle">
    ///               A handle to an iterator resource.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SerializeIterator'.
    ///             </param><returns>
    ///               A variant tensor storing the state of the iterator contained in the
    ///               resource.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SerializeIterator(resource_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SerializeIterator(resource_handle.TFOutput, operName))
    /// <summary>
    ///               Serialize an <c>N</c>-minibatch <c>SparseTensor</c> into an <c>[N, 3]</c><c>Tensor</c> object.
    ///             </summary><param name="sparse_indices">
    ///               2-D.  The <c>indices</c> of the minibatch <c>SparseTensor</c>.
    ///             </param><param name="sparse_values">
    ///               1-D.  The <c>values</c> of the minibatch <c>SparseTensor</c>.
    ///             </param><param name="sparse_shape">
    ///               1-D.  The <c>shape</c> of the minibatch <c>SparseTensor</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SerializeManySparse'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///               The <c>dtype</c> to use for serialization; the supported types are <c>string</c>
    ///               (default) and <c>variant</c>.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The <c>SparseTensor</c> must have rank <c>R</c> greater than 1, and the first dimension
    ///               is treated as the minibatch dimension.  Elements of the <c>SparseTensor</c>
    ///               must be sorted in increasing order of this first dimension.  The serialized
    ///               <c>SparseTensor</c> objects going into each row of <c>serialized_sparse</c> will have
    ///               rank <c>R-1</c>.
    ///               
    ///               The minibatch size <c>N</c> is extracted from <c>sparse_shape[0]</c>.
    ///             </remarks>
    member this.SerializeManySparse(sparse_indices : TF, sparse_values : TF, sparse_shape : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SerializeManySparse(sparse_indices.TFOutput, sparse_values.TFOutput, sparse_shape.TFOutput, out_type, operName))
    /// <summary>
    ///               Serialize a <c>SparseTensor</c> into a <c>[3]</c><c>Tensor</c> object.
    ///             </summary><param name="sparse_indices">
    ///               2-D.  The <c>indices</c> of the <c>SparseTensor</c>.
    ///             </param><param name="sparse_values">
    ///               1-D.  The <c>values</c> of the <c>SparseTensor</c>.
    ///             </param><param name="sparse_shape">
    ///               1-D.  The <c>shape</c> of the <c>SparseTensor</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SerializeSparse'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///               The <c>dtype</c> to use for serialization; the supported types are <c>string</c>
    ///               (default) and <c>variant</c>.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SerializeSparse(sparse_indices : TF, sparse_values : TF, sparse_shape : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SerializeSparse(sparse_indices.TFOutput, sparse_values.TFOutput, sparse_shape.TFOutput, out_type, operName))
    /// <summary>
    ///               Transforms a Tensor into a serialized TensorProto proto.
    ///             </summary><param name="tensor">
    ///               A Tensor of type <c>T</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SerializeTensor'.
    ///             </param><returns>
    ///               A serialized TensorProto proto of the input tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SerializeTensor(tensor : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SerializeTensor(tensor.TFOutput, operName))
    /// <summary>
    ///               Number of unique elements along last dimension of input <c>set</c>.
    ///             </summary><param name="set_indices">
    ///               2D <c>Tensor</c>, indices of a <c>SparseTensor</c>.
    ///             </param><param name="set_values">
    ///               1D <c>Tensor</c>, values of a <c>SparseTensor</c>.
    ///             </param><param name="set_shape">
    ///               1D <c>Tensor</c>, shape of a <c>SparseTensor</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SetSize'.
    ///             </param><param name="validate_indices">
    ///               Optional argument
    ///             </param><returns>
    ///               For <c>set</c> ranked <c>n</c>, this is a <c>Tensor</c> with rank <c>n-1</c>, and the same 1st
    ///               <c>n-1</c> dimensions as <c>set</c>. Each value is the number of unique elements in
    ///               the corresponding <c>[0...n-1]</c> dimension of <c>set</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Input <c>set</c> is a <c>SparseTensor</c> represented by <c>set_indices</c>, <c>set_values</c>,
    ///               and <c>set_shape</c>. The last dimension contains values in a set, duplicates are
    ///               allowed but ignored.
    ///               
    ///               If <c>validate_indices</c> is <c>True</c>, this op validates the order and range of <c>set</c>
    ///               indices.
    ///             </remarks>
    member this.SetSize(set_indices : TF, set_values : TF, set_shape : TF, ?validate_indices : Boolean, ?operName : String) =
        let validate_indices = defaultArg (validate_indices |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SetSize(set_indices.TFOutput, set_values.TFOutput, set_shape.TFOutput, validate_indices, operName))
    /// <summary>
    ///               Returns the shape of a tensor.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Shape'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns a 1-D integer tensor representing the shape of <c>input</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
    ///               shape(t) ==&amp;gt; [2, 2, 3]
    ///                </code></remarks>
    member this.Shape(input : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Shape(input.TFOutput, out_type, operName))
    /// <summary>
    ///               Returns shape of tensors.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ShapeN'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns N 1-D integer tensors representing shape of <c>input[i]s</c>.
    ///             </remarks>
    member this.ShapeN(input : TF[], ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ShapeN(input |> Array.map (fun x -> x.TFOutput), out_type, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Generate a sharded filename. The filename is printf formatted as
    ///             </summary><param name="basename"></param><param name="shard"></param><param name="num_shards"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ShardedFilename'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               %s-%05d-of-%05d, basename, shard, num_shards.
    ///             </remarks>
    member this.ShardedFilename(basename : TF, shard : TF, num_shards : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ShardedFilename(basename.TFOutput, shard.TFOutput, num_shards.TFOutput, operName))
    /// <summary>
    ///               Generate a glob pattern matching all sharded file names.
    ///             </summary><param name="basename"></param><param name="num_shards"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ShardedFilespec'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ShardedFilespec(basename : TF, num_shards : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ShardedFilespec(basename.TFOutput, num_shards.TFOutput, operName))
    /// <summary>
    ///               Creates a dataset that shuffles and repeats elements from <c>input_dataset</c></summary><param name="input_dataset"></param><param name="buffer_size">
    ///               The number of output elements to buffer in an iterator over
    ///               this dataset. Compare with the <c>min_after_dequeue</c> attr when creating a
    ///               <c>RandomShuffleQueue</c>.
    ///             </param><param name="seed">
    ///               A scalar seed for the random number generator. If either <c>seed</c> or
    ///               <c>seed2</c> is set to be non-zero, the random number generator is seeded
    ///               by the given seed.  Otherwise, a random seed is used.
    ///             </param><param name="seed2">
    ///               A second scalar seed to avoid seed collision.
    ///             </param><param name="count">
    ///               A scalar representing the number of times the underlying dataset
    ///               should be repeated. The default is <c>-1</c>, which results in infinite repetition.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ShuffleAndRepeatDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               pseudorandomly.
    ///             </remarks>
    member this.ShuffleAndRepeatDataset(input_dataset : TF, buffer_size : TF, seed : TF, seed2 : TF, count : TF, output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ShuffleAndRepeatDataset(input_dataset.TFOutput, buffer_size.TFOutput, seed.TFOutput, seed2.TFOutput, count.TFOutput, output_types, output_shapes, operName))
    /// <summary>
    ///               Creates a dataset that shuffles elements from <c>input_dataset</c> pseudorandomly.
    ///             </summary><param name="input_dataset"></param><param name="buffer_size">
    ///               The number of output elements to buffer in an iterator over
    ///               this dataset. Compare with the <c>min_after_dequeue</c> attr when creating a
    ///               <c>RandomShuffleQueue</c>.
    ///             </param><param name="seed">
    ///               A scalar seed for the random number generator. If either <c>seed</c> or
    ///               <c>seed2</c> is set to be non-zero, the random number generator is seeded
    ///               by the given seed.  Otherwise, a random seed is used.
    ///             </param><param name="seed2">
    ///               A second scalar seed to avoid seed collision.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ShuffleDataset'.
    ///             </param><param name="reshuffle_each_iteration">
    ///               Optional argument
    ///               If true, each iterator over this dataset will be given
    ///               a different pseudorandomly generated seed, based on a sequence seeded by the
    ///               <c>seed</c> and <c>seed2</c> inputs. If false, each iterator will be given the same
    ///               seed, and repeated iteration over this dataset will yield the exact same
    ///               sequence of results.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ShuffleDataset(input_dataset : TF, buffer_size : TF, seed : TF, seed2 : TF, output_types : TFDataType[], output_shapes : TFShape[], ?reshuffle_each_iteration : Boolean, ?operName : String) =
        let reshuffle_each_iteration = defaultArg (reshuffle_each_iteration |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ShuffleDataset(input_dataset.TFOutput, buffer_size.TFOutput, seed.TFOutput, seed2.TFOutput, output_types, output_shapes, reshuffle_each_iteration, operName))
    /// <summary>
    ///               An op that shuts down a running distributed TPU system. The Op returns
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ShutdownDistributedTPU'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               an error if no system is running.
    ///             </remarks>
    member this.ShutdownDistributedTPU(?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ShutdownDistributedTPU(operName)
    /// <summary>
    ///               Computes sigmoid of <c>x</c> element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sigmoid'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Specifically, <c>y = 1 / (1 + exp(-x))</c>.
    ///             </remarks>
    member this.Sigmoid(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sigmoid(x.TFOutput, operName))
    /// <summary>
    ///               Computes the gradient of the sigmoid of <c>x</c> wrt its input.
    ///             </summary><param name="y"></param><param name="dy"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SigmoidGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Specifically, <c>grad = dy * y * (1 - y)</c>, where <c>y = sigmoid(x)</c>, and
    ///               <c>dy</c> is the corresponding input gradient.
    ///             </remarks>
    member this.SigmoidGrad(y : TF, dy : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SigmoidGrad(y.TFOutput, dy.TFOutput, operName))
    /// <summary>
    ///               Returns an element-wise indication of the sign of a number.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sign'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks><c>y = sign(x) = -1</c> if <c>x &amp;lt; 0</c>; 0 if <c>x == 0</c>; 1 if <c>x &amp;gt; 0</c>.
    ///               
    ///               For complex numbers, <c>y = sign(x) = x / |x|</c> if <c>x != 0</c>, otherwise <c>y = 0</c>.
    ///             </remarks>
    member this.Sign(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sign(x.TFOutput, operName))
    /// <summary>
    ///               Computes sin of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sin'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Sin(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sin(x.TFOutput, operName))
    /// <summary>
    ///               Computes hyperbolic sine of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Sinh'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Sinh(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Sinh(x.TFOutput, operName))
    /// <summary>
    ///               Returns the size of a tensor.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Size'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns an integer representing the number of elements in
    ///               <c>input</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
    ///               size(t) ==&amp;gt; 12
    ///                </code></remarks>
    member this.Size(input : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Size(input.TFOutput, out_type, operName))
    /// <summary>
    ///               Creates a dataset that skips <c>count</c> elements from the <c>input_dataset</c>.
    ///             </summary><param name="input_dataset"></param><param name="count">
    ///               A scalar representing the number of elements from the <c>input_dataset</c>
    ///               that should be skipped.  If count is -1, skips everything.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SkipDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SkipDataset(input_dataset : TF, count : TF, output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SkipDataset(input_dataset.TFOutput, count.TFOutput, output_types, output_shapes, operName))
    /// <summary>
    ///               Parses a text file and creates a batch of examples.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Skipgram'.
    ///             </param><param name="window_size">
    ///               Optional argument
    ///               The number of words to predict to the left and right of the target.
    ///             </param><param name="min_count">
    ///               Optional argument
    ///               The minimum number of word occurrences for it to be included in the
    ///               vocabulary.
    ///             </param><param name="subsample">
    ///               Optional argument
    ///               Threshold for word occurrence. Words that appear with higher
    ///               frequency will be randomly down-sampled. Set to 0 to disable.
    ///             </param><param name="filename">
    ///               The corpus's text file name.
    ///             </param><param name="batch_size">
    ///               The size of produced batch.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               vocab_word: A vector of words in the corpus.
    ///               vocab_freq: Frequencies of words. Sorted in the non-ascending order.
    ///               words_per_epoch: Number of words per epoch in the data file.
    ///               current_epoch: The current epoch number.
    ///               total_words_processed: The total number of words processed so far.
    ///               examples: A vector of word ids.
    ///               labels: A vector of word ids.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.Skipgram(filename : String, batch_size : Int64, ?window_size : Int64, ?min_count : Int64, ?subsample : Single, ?operName : String) =
        let window_size = defaultArg (window_size |> Option.map Nullable) (Nullable())
        let min_count = defaultArg (min_count |> Option.map Nullable) (Nullable())
        let subsample = defaultArg (subsample |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.Skipgram(filename, batch_size, window_size, min_count, subsample, operName)
    /// <summary>
    ///               Return a slice from 'input'.
    ///             </summary><param name="input"></param><param name="begin">
    ///               begin[i] specifies the offset into the 'i'th dimension of
    ///               'input' to slice from.
    ///             </param><param name="size">
    ///               size[i] specifies the number of elements of the 'i'th dimension
    ///               of 'input' to slice. If size[i] is -1, all remaining elements in dimension
    ///               i are included in the slice (i.e. this is equivalent to setting
    ///               size[i] = input.dim_size(i) - begin[i]).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Slice'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The output tensor is a tensor with dimensions described by 'size'
    ///               whose values are extracted from 'input' starting at the offsets in
    ///               'begin'.
    ///               
    ///               *Requirements*:
    ///               0 &amp;lt;= begin[i] &amp;lt;= begin[i] + size[i] &amp;lt;= Di  for i in [0, n)
    ///             </remarks>
    member this.Slice(input : TF, ``begin`` : TF, size : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Slice(input.TFOutput, ``begin``.TFOutput, size.TFOutput, operName))
    /// <summary>
    ///               Returns a copy of the input tensor.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Snapshot'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Snapshot(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Snapshot(input.TFOutput, operName))
    /// <summary>
    ///               Computes softmax activations.
    ///             </summary><param name="logits">
    ///               2-D with shape <c>[batch_size, num_classes]</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Softmax'.
    ///             </param><returns>
    ///               Same shape as <c>logits</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               For each batch <c>i</c> and class <c>j</c> we have
    ///               
    ///               $$softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))$$
    ///             </remarks>
    member this.Softmax(logits : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Softmax(logits.TFOutput, operName))
    /// <summary>
    ///               Computes softmax cross entropy cost and gradients to backpropagate.
    ///             </summary><param name="features">
    ///               batch_size x num_classes matrix
    ///             </param><param name="labels">
    ///               batch_size x num_classes matrix
    ///               The caller must ensure that each batch of labels represents a valid
    ///               probability distribution.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SoftmaxCrossEntropyWithLogits'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               loss: Per example loss (batch_size vector).
    ///               backprop: backpropagated gradients (batch_size x num_classes matrix).
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Inputs are the logits, not probabilities.
    ///             </remarks>
    member this.SoftmaxCrossEntropyWithLogits(features : TF, labels : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SoftmaxCrossEntropyWithLogits(features.TFOutput, labels.TFOutput, operName)
    /// <summary>
    ///               Computes softplus: <c>log(exp(features) + 1)</c>.
    ///             </summary><param name="features"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Softplus'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Softplus(features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Softplus(features.TFOutput, operName))
    /// <summary>
    ///               Computes softplus gradients for a softplus operation.
    ///             </summary><param name="gradients">
    ///               The backpropagated gradients to the corresponding softplus operation.
    ///             </param><param name="features">
    ///               The features passed as input to the corresponding softplus operation.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SoftplusGrad'.
    ///             </param><returns>
    ///               The gradients: <c>gradients / (1 + exp(-features))</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SoftplusGrad(gradients : TF, features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SoftplusGrad(gradients.TFOutput, features.TFOutput, operName))
    /// <summary>
    ///               Computes softsign: <c>features / (abs(features) + 1)</c>.
    ///             </summary><param name="features"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Softsign'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Softsign(features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Softsign(features.TFOutput, operName))
    /// <summary>
    ///               Computes softsign gradients for a softsign operation.
    ///             </summary><param name="gradients">
    ///               The backpropagated gradients to the corresponding softsign operation.
    ///             </param><param name="features">
    ///               The features passed as input to the corresponding softsign operation.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SoftsignGrad'.
    ///             </param><returns>
    ///               The gradients: <c>gradients / (1 + abs(features)) ** 2</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SoftsignGrad(gradients : TF, features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SoftsignGrad(gradients.TFOutput, features.TFOutput, operName))
    /// <summary>
    ///               SpaceToBatch for 4-D tensors of type T.
    ///             </summary><param name="input">
    ///               4-D with shape <c>[batch, height, width, depth]</c>.
    ///             </param><param name="paddings">
    ///               2-D tensor of non-negative integers with shape <c>[2, 2]</c>. It specifies
    ///               the padding of the input with zeros across the spatial dimensions as follows:
    ///               
    ///               paddings = [[pad_top, pad_bottom], [pad_left, pad_right]]
    ///               
    ///               The effective spatial dimensions of the zero-padded input tensor will be:
    ///               
    ///               height_pad = pad_top + height + pad_bottom
    ///               width_pad = pad_left + width + pad_right
    ///               
    ///               The attr <c>block_size</c> must be greater than one. It indicates the block size.
    ///               
    ///               * Non-overlapping blocks of size <c>block_size x block size</c> in the height and
    ///               width dimensions are rearranged into the batch dimension at each location.
    ///               * The batch of the output tensor is <c>batch * block_size * block_size</c>.
    ///               * Both height_pad and width_pad must be divisible by block_size.
    ///               
    ///               The shape of the output will be:
    ///               
    ///               [batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
    ///               depth]
    ///               
    ///               Some examples:
    ///               
    ///               (1) For the following input of shape <c>[1, 2, 2, 1]</c> and block_size of 2:
    ///               
    ///                <code>
    ///               x = [[[[1], [2]], [[3], [4]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[4, 1, 1, 1]</c> and value:
    ///               
    ///                <code>
    ///               [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
    ///                </code>
    ///               
    ///               (2) For the following input of shape <c>[1, 2, 2, 3]</c> and block_size of 2:
    ///               
    ///                <code>
    ///               x = [[[[1, 2, 3], [4, 5, 6]],
    ///               [[7, 8, 9], [10, 11, 12]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[4, 1, 1, 3]</c> and value:
    ///               
    ///                <code>
    ///               [[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
    ///                </code>
    ///               
    ///               (3) For the following input of shape <c>[1, 4, 4, 1]</c> and block_size of 2:
    ///               
    ///                <code>
    ///               x = [[[[1],   [2],  [3],  [4]],
    ///               [[5],   [6],  [7],  [8]],
    ///               [[9],  [10], [11],  [12]],
    ///               [[13], [14], [15],  [16]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[4, 2, 2, 1]</c> and value:
    ///               
    ///                <code>
    ///               x = [[[[1], [3]], [[9], [11]]],
    ///               [[[2], [4]], [[10], [12]]],
    ///               [[[5], [7]], [[13], [15]]],
    ///               [[[6], [8]], [[14], [16]]]]
    ///                </code>
    ///               
    ///               (4) For the following input of shape <c>[2, 2, 4, 1]</c> and block_size of 2:
    ///               
    ///                <code>
    ///               x = [[[[1],   [2],  [3],  [4]],
    ///               [[5],   [6],  [7],  [8]]],
    ///               [[[9],  [10], [11],  [12]],
    ///               [[13], [14], [15],  [16]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[8, 1, 2, 1]</c> and value:
    ///               
    ///                <code>
    ///               x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
    ///               [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
    ///                </code>
    ///               
    ///               Among others, this operation is useful for reducing atrous convolution into
    ///               regular convolution.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SpaceToBatch'.
    ///             </param><param name="block_size"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This is a legacy version of the more general SpaceToBatchND.
    ///               
    ///               Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
    ///               More specifically, this op outputs a copy of the input tensor where values from
    ///               the <c>height</c> and <c>width</c> dimensions are moved to the <c>batch</c> dimension. After
    ///               the zero-padding, both <c>height</c> and <c>width</c> of the input must be divisible by the
    ///               block size.
    ///             </remarks>
    member this.SpaceToBatch(input : TF, paddings : TF, block_size : Int64, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SpaceToBatch(input.TFOutput, paddings.TFOutput, block_size, operName))
    /// <summary>
    ///               SpaceToBatch for N-D tensors of type T.
    ///             </summary><param name="input">
    ///               N-D with shape <c>input_shape = [batch] + spatial_shape + remaining_shape</c>,
    ///               where spatial_shape has <c>M</c> dimensions.
    ///             </param><param name="block_shape">
    ///               1-D with shape <c>[M]</c>, all values must be &amp;gt;= 1.
    ///             </param><param name="paddings">
    ///               2-D with shape <c>[M, 2]</c>, all values must be &amp;gt;= 0.
    ///               <c>paddings[i] = [pad_start, pad_end]</c> specifies the padding for input dimension
    ///               <c>i + 1</c>, which corresponds to spatial dimension <c>i</c>.  It is required that
    ///               <c>block_shape[i]</c> divides <c>input_shape[i + 1] + pad_start + pad_end</c>.
    ///               
    ///               This operation is equivalent to the following steps:
    ///               
    ///               1. Zero-pad the start and end of dimensions <c>[1, ..., M]</c> of the
    ///               input according to <c>paddings</c> to produce <c>padded</c> of shape <c>padded_shape</c>.
    ///               
    ///               2. Reshape <c>padded</c> to <c>reshaped_padded</c> of shape:
    ///               
    ///               [batch] +
    ///               [padded_shape[1] / block_shape[0],
    ///               block_shape[0],
    ///               ...,
    ///               padded_shape[M] / block_shape[M-1],
    ///               block_shape[M-1]] +
    ///               remaining_shape
    ///               
    ///               3. Permute dimensions of <c>reshaped_padded</c> to produce
    ///               <c>permuted_reshaped_padded</c> of shape:
    ///               
    ///               block_shape +
    ///               [batch] +
    ///               [padded_shape[1] / block_shape[0],
    ///               ...,
    ///               padded_shape[M] / block_shape[M-1]] +
    ///               remaining_shape
    ///               
    ///               4. Reshape <c>permuted_reshaped_padded</c> to flatten <c>block_shape</c> into the batch
    ///               dimension, producing an output tensor of shape:
    ///               
    ///               [batch * prod(block_shape)] +
    ///               [padded_shape[1] / block_shape[0],
    ///               ...,
    ///               padded_shape[M] / block_shape[M-1]] +
    ///               remaining_shape
    ///               
    ///               Some examples:
    ///               
    ///               (1) For the following input of shape <c>[1, 2, 2, 1]</c>, <c>block_shape = [2, 2]</c>, and
    ///               <c>paddings = [[0, 0], [0, 0]]</c>:
    ///               
    ///                <code>
    ///               x = [[[[1], [2]], [[3], [4]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[4, 1, 1, 1]</c> and value:
    ///               
    ///                <code>
    ///               [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
    ///                </code>
    ///               
    ///               (2) For the following input of shape <c>[1, 2, 2, 3]</c>, <c>block_shape = [2, 2]</c>, and
    ///               <c>paddings = [[0, 0], [0, 0]]</c>:
    ///               
    ///                <code>
    ///               x = [[[[1, 2, 3], [4, 5, 6]],
    ///               [[7, 8, 9], [10, 11, 12]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[4, 1, 1, 3]</c> and value:
    ///               
    ///                <code>
    ///               [[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
    ///                </code>
    ///               
    ///               (3) For the following input of shape <c>[1, 4, 4, 1]</c>, <c>block_shape = [2, 2]</c>, and
    ///               <c>paddings = [[0, 0], [0, 0]]</c>:
    ///               
    ///                <code>
    ///               x = [[[[1],   [2],  [3],  [4]],
    ///               [[5],   [6],  [7],  [8]],
    ///               [[9],  [10], [11],  [12]],
    ///               [[13], [14], [15],  [16]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[4, 2, 2, 1]</c> and value:
    ///               
    ///                <code>
    ///               x = [[[[1], [3]], [[9], [11]]],
    ///               [[[2], [4]], [[10], [12]]],
    ///               [[[5], [7]], [[13], [15]]],
    ///               [[[6], [8]], [[14], [16]]]]
    ///                </code>
    ///               
    ///               (4) For the following input of shape <c>[2, 2, 4, 1]</c>, block_shape = <c>[2, 2]</c>, and
    ///               paddings = <c>[[0, 0], [2, 0]]</c>:
    ///               
    ///                <code>
    ///               x = [[[[1],   [2],  [3],  [4]],
    ///               [[5],   [6],  [7],  [8]]],
    ///               [[[9],  [10], [11],  [12]],
    ///               [[13], [14], [15],  [16]]]]
    ///                </code>
    ///               
    ///               The output tensor has shape <c>[8, 1, 3, 1]</c> and value:
    ///               
    ///                <code>
    ///               x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
    ///               [[[0], [2], [4]]], [[[0], [10], [12]]],
    ///               [[[0], [5], [7]]], [[[0], [13], [15]]],
    ///               [[[0], [6], [8]]], [[[0], [14], [16]]]]
    ///                </code>
    ///               
    ///               Among others, this operation is useful for reducing atrous convolution into
    ///               regular convolution.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SpaceToBatchND'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation divides "spatial" dimensions <c>[1, ..., M]</c> of the input into a
    ///               grid of blocks of shape <c>block_shape</c>, and interleaves these blocks with the
    ///               "batch" dimension (0) such that in the output, the spatial dimensions
    ///               <c>[1, ..., M]</c> correspond to the position within the grid, and the batch
    ///               dimension combines both the position within a spatial block and the original
    ///               batch position.  Prior to division into blocks, the spatial dimensions of the
    ///               input are optionally zero padded according to <c>paddings</c>.  See below for a
    ///               precise description.
    ///             </remarks>
    member this.SpaceToBatchND(input : TF, block_shape : TF, paddings : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SpaceToBatchND(input.TFOutput, block_shape.TFOutput, paddings.TFOutput, operName))
    /// <summary>
    ///               SpaceToDepth for tensors of type T.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SpaceToDepth'.
    ///             </param><param name="data_format">
    ///               Optional argument
    ///             </param><param name="block_size">
    ///               The size of the spatial block.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Rearranges blocks of spatial data, into depth. More specifically,
    ///               this op outputs a copy of the input tensor where values from the <c>height</c>
    ///               and <c>width</c> dimensions are moved to the <c>depth</c> dimension.
    ///               The attr <c>block_size</c> indicates the input block size.
    ///               
    ///               * Non-overlapping blocks of size <c>block_size x block size</c> are rearranged
    ///               into depth at each location.
    ///               * The depth of the output tensor is <c>block_size * block_size * input_depth</c>.
    ///               * The Y, X coordinates within each block of the input become the high order
    ///               component of the output channel index.
    ///               * The input tensor's height and width must be divisible by block_size.
    ///               
    ///               The <c>data_format</c> attr specifies the layout of the input and output tensors
    ///               with the following options:
    ///               "NHWC": <c>[ batch, height, width, channels ]</c>
    ///               "NCHW": <c>[ batch, channels, height, width ]</c>
    ///               "NCHW_VECT_C":
    ///               <c>qint8 [ batch, channels / 4, height, width, 4 ]</c>
    ///               
    ///               It is useful to consider the operation as transforming a 6-D Tensor.
    ///               e.g. for data_format = NHWC,
    ///               Each element in the input tensor can be specified via 6 coordinates,
    ///               ordered by decreasing memory layout significance as:
    ///               n,oY,bY,oX,bX,iC  (where n=batch index, oX, oY means X or Y coordinates
    ///               within the output image, bX, bY means coordinates
    ///               within the input block, iC means input channels).
    ///               The output would be a transpose to the following layout:
    ///               n,oY,oX,bY,bX,iC
    ///               
    ///               This operation is useful for resizing the activations between convolutions
    ///               (but keeping all data), e.g. instead of pooling. It is also useful for training
    ///               purely convolutional models.
    ///               
    ///               For example, given an input of shape <c>[1, 2, 2, 1]</c>, data_format = "NHWC" and
    ///               block_size = 2:
    ///               
    ///                <code>
    ///               x = [[[[1], [2]],
    ///               [[3], [4]]]]
    ///                </code>
    ///               
    ///               This operation will output a tensor of shape <c>[1, 1, 1, 4]</c>:
    ///               
    ///                <code>
    ///               [[[[1, 2, 3, 4]]]]
    ///                </code>
    ///               
    ///               Here, the input has a batch of 1 and each batch element has shape <c>[2, 2, 1]</c>,
    ///               the corresponding output will have a single element (i.e. width and height are
    ///               both 1) and will have a depth of 4 channels (1 * block_size * block_size).
    ///               The output element shape is <c>[1, 1, 4]</c>.
    ///               
    ///               For an input tensor with larger depth, here of shape <c>[1, 2, 2, 3]</c>, e.g.
    ///               
    ///                <code>
    ///               x = [[[[1, 2, 3], [4, 5, 6]],
    ///               [[7, 8, 9], [10, 11, 12]]]]
    ///                </code>
    ///               
    ///               This operation, for block_size of 2, will return the following tensor of shape
    ///               <c>[1, 1, 1, 12]</c><code>
    ///               [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
    ///                </code>
    ///               
    ///               Similarly, for the following input of shape <c>[1 4 4 1]</c>, and a block size of 2:
    ///               
    ///                <code>
    ///               x = [[[[1],   [2],  [5],  [6]],
    ///               [[3],   [4],  [7],  [8]],
    ///               [[9],  [10], [13],  [14]],
    ///               [[11], [12], [15],  [16]]]]
    ///                </code>
    ///               
    ///               the operator will return the following tensor of shape <c>[1 2 2 4]</c>:
    ///               
    ///                <code>
    ///               x = [[[[1, 2, 3, 4],
    ///               [5, 6, 7, 8]],
    ///               [[9, 10, 11, 12],
    ///               [13, 14, 15, 16]]]]
    ///                </code></remarks>
    member this.SpaceToDepth(input : TF, block_size : Int64, ?data_format : String, ?operName : String) =
        let data_format = defaultArg data_format null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SpaceToDepth(input.TFOutput, block_size, data_format, operName))
    /// <summary>
    ///               Applies a sparse gradient to a given accumulator.
    ///             </summary><param name="handle">
    ///               The handle to a accumulator.
    ///             </param><param name="local_step">
    ///               The local_step value at which the sparse gradient was computed.
    ///             </param><param name="gradient_indices">
    ///               Indices of the sparse gradient to be accumulated. Must be a
    ///               vector.
    ///             </param><param name="gradient_values">
    ///               Values are the non-zero slices of the gradient, and must have
    ///               the same first dimension as indices, i.e., the nnz represented by indices and
    ///               values must be consistent.
    ///             </param><param name="gradient_shape">
    ///               Shape of the sparse gradient to be accumulated.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseAccumulatorApplyGradient'.
    ///             </param><param name="has_known_shape">
    ///               Boolean indicating whether gradient_shape is unknown, in which
    ///               case the input is ignored during validation.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               Does not add if local_step is smaller than the accumulator's
    ///               global_step.
    ///             </remarks>
    member this.SparseAccumulatorApplyGradient(handle : TF, local_step : TF, gradient_indices : TF, gradient_values : TF, gradient_shape : TF, has_known_shape : Boolean, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseAccumulatorApplyGradient(handle.TFOutput, local_step.TFOutput, gradient_indices.TFOutput, gradient_values.TFOutput, gradient_shape.TFOutput, has_known_shape, operName)
    /// <summary>
    ///               Extracts the average sparse gradient in a SparseConditionalAccumulator.
    ///             </summary><param name="handle">
    ///               The handle to a SparseConditionalAccumulator.
    ///             </param><param name="num_required">
    ///               Number of gradients required before we return an aggregate.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseAccumulatorTakeGradient'.
    ///             </param><param name="dtype">
    ///               The data type of accumulated gradients. Needs to correspond to the type
    ///               of the accumulator.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               indices: Indices of the average of the accumulated sparse gradients.
    ///               values: Values of the average of the accumulated sparse gradients.
    ///               shape: Shape of the average of the accumulated sparse gradients.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The op will blocks until sufficient (i.e., more than num_required)
    ///               gradients have been accumulated. If the accumulator has already
    ///               aggregated more than num_required gradients, it will return its
    ///               average of the accumulated gradients.  Also automatically increments
    ///               the recorded global_step in the accumulator by 1, and resets the
    ///               aggregate to 0.
    ///             </remarks>
    member this.SparseAccumulatorTakeGradient(handle : TF, num_required : TF, dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseAccumulatorTakeGradient(handle.TFOutput, num_required.TFOutput, dtype, operName)
    /// <summary>
    ///               Adds two <c>SparseTensor</c> objects to produce another <c>SparseTensor</c>.
    ///             </summary><param name="a_indices">
    ///               2-D.  The <c>indices</c> of the first <c>SparseTensor</c>, size <c>[nnz, ndims]</c> Matrix.
    ///             </param><param name="a_values">
    ///               1-D.  The <c>values</c> of the first <c>SparseTensor</c>, size <c>[nnz]</c> Vector.
    ///             </param><param name="a_shape">
    ///               1-D.  The <c>shape</c> of the first <c>SparseTensor</c>, size <c>[ndims]</c> Vector.
    ///             </param><param name="b_indices">
    ///               2-D.  The <c>indices</c> of the second <c>SparseTensor</c>, size <c>[nnz, ndims]</c> Matrix.
    ///             </param><param name="b_values">
    ///               1-D.  The <c>values</c> of the second <c>SparseTensor</c>, size <c>[nnz]</c> Vector.
    ///             </param><param name="b_shape">
    ///               1-D.  The <c>shape</c> of the second <c>SparseTensor</c>, size <c>[ndims]</c> Vector.
    ///             </param><param name="thresh">
    ///               0-D.  The magnitude threshold that determines if an output value/index
    ///               pair takes space.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseAdd'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               sum_indices:
    ///               sum_values:
    ///               sum_shape:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The input <c>SparseTensor</c> objects' indices are assumed ordered in standard
    ///               lexicographic order.  If this is not the case, before this step run
    ///               <c>SparseReorder</c> to restore index ordering.
    ///               
    ///               By default, if two values sum to zero at some index, the output <c>SparseTensor</c>
    ///               would still include that particular location in its index, storing a zero in the
    ///               corresponding value slot.  To override this, callers can specify <c>thresh</c>,
    ///               indicating that if the sum has a magnitude strictly smaller than <c>thresh</c>, its
    ///               corresponding value and index would then not be included.  In particular,
    ///               <c>thresh == 0</c> (default) means everything is kept and actual thresholding happens
    ///               only for a positive value.
    ///               
    ///               In the following shapes, <c>nnz</c> is the count after taking <c>thresh</c> into account.
    ///             </remarks>
    member this.SparseAdd(a_indices : TF, a_values : TF, a_shape : TF, b_indices : TF, b_values : TF, b_shape : TF, thresh : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseAdd(a_indices.TFOutput, a_values.TFOutput, a_shape.TFOutput, b_indices.TFOutput, b_values.TFOutput, b_shape.TFOutput, thresh.TFOutput, operName)
    /// <summary>
    ///               The gradient operator for the SparseAdd op.
    ///             </summary><param name="backprop_val_grad">
    ///               1-D with shape <c>[nnz(sum)]</c>.  The gradient with respect to
    ///               the non-empty values of the sum.
    ///             </param><param name="a_indices">
    ///               2-D.  The <c>indices</c> of the <c>SparseTensor</c> A, size <c>[nnz(A), ndims]</c>.
    ///             </param><param name="b_indices">
    ///               2-D.  The <c>indices</c> of the <c>SparseTensor</c> B, size <c>[nnz(B), ndims]</c>.
    ///             </param><param name="sum_indices">
    ///               2-D.  The <c>indices</c> of the sum <c>SparseTensor</c>, size
    ///               <c>[nnz(sum), ndims]</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseAddGrad'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               a_val_grad: 1-D with shape <c>[nnz(A)]</c>. The gradient with respect to the
    ///               non-empty values of A.
    ///               b_val_grad: 1-D with shape <c>[nnz(B)]</c>. The gradient with respect to the
    ///               non-empty values of B.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The SparseAdd op calculates A + B, where A, B, and the sum are all represented
    ///               as <c>SparseTensor</c> objects.  This op takes in the upstream gradient w.r.t.
    ///               non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
    ///               values of A and B.
    ///             </remarks>
    member this.SparseAddGrad(backprop_val_grad : TF, a_indices : TF, b_indices : TF, sum_indices : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseAddGrad(backprop_val_grad.TFOutput, a_indices.TFOutput, b_indices.TFOutput, sum_indices.TFOutput, operName)
    /// <summary>
    ///               var: Should be from a Variable().
    ///             </summary><param name="var"></param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="accum_update">
    ///               : Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay factor. Must be a scalar.
    ///             </param><param name="epsilon">
    ///               Constant factor. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyAdadelta'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SparseApplyAdadelta(var : TF, accum : TF, accum_update : TF, lr : TF, rho : TF, epsilon : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyAdadelta(var.TFOutput, accum.TFOutput, accum_update.TFOutput, lr.TFOutput, rho.TFOutput, epsilon.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName))
    /// <summary>
    ///               Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyAdagrad'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="update_slots">
    ///               Optional argument
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var and accum as follows:
    ///               $$accum += grad * grad$$
    ///               $$var -= lr * grad * (1 / sqrt(accum))$$
    ///             </remarks>
    member this.SparseApplyAdagrad(var : TF, accum : TF, lr : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?update_slots : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let update_slots = defaultArg (update_slots |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyAdagrad(var.TFOutput, accum.TFOutput, lr.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, update_slots, operName))
    /// <summary>
    ///               Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="gradient_accumulator">
    ///               Should be from a Variable().
    ///             </param><param name="gradient_squared_accumulator">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="global_step">
    ///               Training step number. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyAdagradDA'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.SparseApplyAdagradDA(var : TF, gradient_accumulator : TF, gradient_squared_accumulator : TF, grad : TF, indices : TF, lr : TF, l1 : TF, l2 : TF, global_step : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyAdagradDA(var.TFOutput, gradient_accumulator.TFOutput, gradient_squared_accumulator.TFOutput, grad.TFOutput, indices.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, global_step.TFOutput, use_locking, operName))
    /// <summary>
    ///               Update '*var' according to the centered RMSProp algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="mg">
    ///               Should be from a Variable().
    ///             </param><param name="ms">
    ///               Should be from a Variable().
    ///             </param><param name="mom">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay rate. Must be a scalar.
    ///             </param><param name="momentum"></param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var, ms and mom.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyCenteredRMSProp'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, mg, ms, and mom tensors is
    ///               protected by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The centered RMSProp algorithm uses an estimate of the centered second moment
    ///               (i.e., the variance) for normalization, as opposed to regular RMSProp, which
    ///               uses the (uncentered) second moment. This often helps with training, but is
    ///               slightly more expensive in terms of computation and memory.
    ///               
    ///               Note that in dense implementation of this algorithm, mg, ms, and mom will
    ///               update even if the grad is zero, but in this sparse implementation, mg, ms,
    ///               and mom will not update in iterations during which the grad is zero.
    ///               
    ///               mean_square = decay * mean_square + (1-decay) * gradient ** 2
    ///               mean_grad = decay * mean_grad + (1-decay) * gradient
    ///               Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
    ///               
    ///               $$ms &amp;lt;- rho * ms_{t-1} + (1-rho) * grad * grad$$
    ///               $$mom &amp;lt;- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)$$
    ///               $$var &amp;lt;- var - mom$$
    ///             </remarks>
    member this.SparseApplyCenteredRMSProp(var : TF, mg : TF, ms : TF, mom : TF, lr : TF, rho : TF, momentum : TF, epsilon : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyCenteredRMSProp(var.TFOutput, mg.TFOutput, ms.TFOutput, mom.TFOutput, lr.TFOutput, rho.TFOutput, momentum.TFOutput, epsilon.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName))
    /// <summary>
    ///               Update relevant entries in '*var' according to the Ftrl-proximal scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="linear">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="lr_power">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyFtrl'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var, accum and linear as follows:
    ///               $$accum_new = accum + grad * grad$$
    ///               $$linear += grad + (accum_{new}^{-lr_{power}} - accum^{-lr_{power}} / lr * var$$
    ///               $$quadratic = 1.0 / (accum_{new}^{lr_{power}} * lr) + 2 * l2$$
    ///               $$var = (sign(linear) * l1 - linear) / quadratic\ if\ |linear| &amp;gt; l1\ else\ 0.0$$
    ///               $$accum = accum_{new}$$
    ///             </remarks>
    member this.SparseApplyFtrl(var : TF, accum : TF, linear : TF, grad : TF, indices : TF, lr : TF, l1 : TF, l2 : TF, lr_power : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyFtrl(var.TFOutput, accum.TFOutput, linear.TFOutput, grad.TFOutput, indices.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, lr_power.TFOutput, use_locking, operName))
    /// <summary>
    ///               Update relevant entries in '*var' according to the Ftrl-proximal scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="linear">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 shrinkage regulariation. Must be a scalar.
    ///             </param><param name="l2_shrinkage"></param><param name="lr_power">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyFtrlV2'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var, accum and linear as follows:
    ///               grad_with_shrinkage = grad + 2 * l2_shrinkage * var
    ///               accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
    ///               linear += grad_with_shrinkage +
    ///               (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
    ///               quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
    ///               var = (sign(linear) * l1 - linear) / quadratic if |linear| &amp;gt; l1 else 0.0
    ///               accum = accum_new
    ///             </remarks>
    member this.SparseApplyFtrlV2(var : TF, accum : TF, linear : TF, grad : TF, indices : TF, lr : TF, l1 : TF, l2 : TF, l2_shrinkage : TF, lr_power : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyFtrlV2(var.TFOutput, accum.TFOutput, linear.TFOutput, grad.TFOutput, indices.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, l2_shrinkage.TFOutput, lr_power.TFOutput, use_locking, operName))
    /// <summary>
    ///               Update relevant entries in '*var' and '*accum' according to the momentum scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="momentum">
    ///               Momentum. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyMomentum'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="use_nesterov">
    ///               Optional argument
    ///               If <c>True</c>, the tensor passed to compute grad will be
    ///               var - lr * momentum * accum, so in the end, the var you get is actually
    ///               var - lr * momentum * accum.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Set use_nesterov = True if you want to use Nesterov momentum.
    ///               
    ///               That is for rows we have grad for, we update var and accum as follows:
    ///               
    ///               $$accum = accum * momentum + grad$$
    ///               $$var -= lr * accum$$
    ///             </remarks>
    member this.SparseApplyMomentum(var : TF, accum : TF, lr : TF, grad : TF, indices : TF, momentum : TF, ?use_locking : Boolean, ?use_nesterov : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let use_nesterov = defaultArg (use_nesterov |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyMomentum(var.TFOutput, accum.TFOutput, lr.TFOutput, grad.TFOutput, indices.TFOutput, momentum.TFOutput, use_locking, use_nesterov, operName))
    /// <summary>
    ///               Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyProximalAdagrad'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var and accum as follows:
    ///               $$accum += grad * grad$$
    ///               $$prox_v = var$$
    ///               $$prox_v -= lr * grad * (1 / sqrt(accum))$$
    ///               $$var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}$$
    ///             </remarks>
    member this.SparseApplyProximalAdagrad(var : TF, accum : TF, lr : TF, l1 : TF, l2 : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyProximalAdagrad(var.TFOutput, accum.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName))
    /// <summary>
    ///               Sparse update '*var' as FOBOS algorithm with fixed learning rate.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="alpha">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyProximalGradientDescent'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the subtraction will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var as follows:
    ///               $$prox_v = var - alpha * grad$$
    ///               $$var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}$$
    ///             </remarks>
    member this.SparseApplyProximalGradientDescent(var : TF, alpha : TF, l1 : TF, l2 : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyProximalGradientDescent(var.TFOutput, alpha.TFOutput, l1.TFOutput, l2.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName))
    /// <summary>
    ///               Update '*var' according to the RMSProp algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="ms">
    ///               Should be from a Variable().
    ///             </param><param name="mom">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay rate. Must be a scalar.
    ///             </param><param name="momentum"></param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var, ms and mom.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseApplyRMSProp'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, ms, and mom tensors is protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Same as "var".
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Note that in dense implementation of this algorithm, ms and mom will
    ///               update even if the grad is zero, but in this sparse implementation, ms
    ///               and mom will not update in iterations during which the grad is zero.
    ///               
    ///               mean_square = decay * mean_square + (1-decay) * gradient ** 2
    ///               Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
    ///               
    ///               $$ms &amp;lt;- rho * ms_{t-1} + (1-rho) * grad * grad$$
    ///               $$mom &amp;lt;- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)$$
    ///               $$var &amp;lt;- var - mom$$
    ///             </remarks>
    member this.SparseApplyRMSProp(var : TF, ms : TF, mom : TF, lr : TF, rho : TF, momentum : TF, epsilon : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseApplyRMSProp(var.TFOutput, ms.TFOutput, mom.TFOutput, lr.TFOutput, rho.TFOutput, momentum.TFOutput, epsilon.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName))
    /// <summary>
    ///               Concatenates a list of <c>SparseTensor</c> along the specified dimension.
    ///             </summary><param name="indices">
    ///               2-D.  Indices of each input <c>SparseTensor</c>.
    ///             </param><param name="values">
    ///               1-D.  Non-empty values of each <c>SparseTensor</c>.
    ///             </param><param name="shapes">
    ///               1-D.  Shapes of each <c>SparseTensor</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseConcat'.
    ///             </param><param name="concat_dim">
    ///               Dimension to concatenate along. Must be in range [-rank, rank),
    ///               where rank is the number of dimensions in each input <c>SparseTensor</c>.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices: 2-D.  Indices of the concatenated <c>SparseTensor</c>.
    ///               output_values: 1-D.  Non-empty values of the concatenated <c>SparseTensor</c>.
    ///               output_shape: 1-D.  Shape of the concatenated <c>SparseTensor</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Concatenation is with respect to the dense versions of these sparse tensors.
    ///               It is assumed that each input is a <c>SparseTensor</c> whose elements are ordered
    ///               along increasing dimension number.
    ///               
    ///               All inputs' shapes must match, except for the concat dimension.  The
    ///               <c>indices</c>, <c>values</c>, and <c>shapes</c> lists must have the same length.
    ///               
    ///               The output shape is identical to the inputs', except along the concat
    ///               dimension, where it is the sum of the inputs' sizes along that dimension.
    ///               
    ///               The output elements will be resorted to preserve the sort order along
    ///               increasing dimension number.
    ///               
    ///               This op runs in <c>O(M log M)</c> time, where <c>M</c> is the total number of non-empty
    ///               values across all inputs. This is due to the need for an internal sort in
    ///               order to concatenate efficiently across an arbitrary dimension.
    ///               
    ///               For example, if <c>concat_dim = 1</c> and the inputs are
    ///               
    ///               sp_inputs[0]: shape = [2, 3]
    ///               [0, 2]: "a"
    ///               [1, 0]: "b"
    ///               [1, 1]: "c"
    ///               
    ///               sp_inputs[1]: shape = [2, 4]
    ///               [0, 1]: "d"
    ///               [0, 2]: "e"
    ///               
    ///               then the output will be
    ///               
    ///               shape = [2, 7]
    ///               [0, 2]: "a"
    ///               [0, 4]: "d"
    ///               [0, 5]: "e"
    ///               [1, 0]: "b"
    ///               [1, 1]: "c"
    ///               
    ///               Graphically this is equivalent to doing
    ///               
    ///               [    a] concat [  d e  ] = [    a   d e  ]
    ///               [b c  ]        [       ]   [b c          ]
    ///             </remarks>
    member this.SparseConcat(indices : TF[], values : TF[], shapes : TF[], concat_dim : Int64, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseConcat(indices |> Array.map (fun x -> x.TFOutput), values |> Array.map (fun x -> x.TFOutput), shapes |> Array.map (fun x -> x.TFOutput), concat_dim, operName)
    /// <summary>
    ///               A conditional accumulator for aggregating sparse gradients.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseConditionalAccumulator'.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this accumulator is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this accumulator will be shared under the given name
    ///               across multiple sessions.
    ///             </param><param name="reduction_type">
    ///               Optional argument
    ///             </param><param name="dtype">
    ///               The type of the value being accumulated.
    ///             </param><param name="shape">
    ///               The shape of the values.
    ///             </param><returns>
    ///               The handle to the accumulator.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The accumulator accepts gradients marked with local_step greater or
    ///               equal to the most recent global_step known to the accumulator. The
    ///               average can be extracted from the accumulator, provided sufficient
    ///               gradients have been accumulated. Extracting the average automatically
    ///               resets the aggregate to 0, and increments the global_step recorded by
    ///               the accumulator.
    ///             </remarks>
    member this.SparseConditionalAccumulator(dtype : TFDataType, shape : TFShape, ?container : String, ?shared_name : String, ?reduction_type : String, ?operName : String) =
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let reduction_type = defaultArg reduction_type null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseConditionalAccumulator(dtype, shape, container, shared_name, reduction_type, operName))
    /// <summary>
    ///               Generates sparse cross from a list of sparse and dense tensors.
    ///             </summary><param name="indices">
    ///               2-D.  Indices of each input <c>SparseTensor</c>.
    ///             </param><param name="values">
    ///               1-D.   values of each <c>SparseTensor</c>.
    ///             </param><param name="shapes">
    ///               1-D.   Shapes of each <c>SparseTensor</c>.
    ///             </param><param name="dense_inputs">
    ///               2-D.    Columns represented by dense <c>Tensor</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseCross'.
    ///             </param><param name="hashed_output">
    ///               If true, returns the hash of the cross instead of the string.
    ///               This will allow us avoiding string manipulations.
    ///             </param><param name="num_buckets">
    ///               It is used if hashed_output is true.
    ///               output = hashed_value%num_buckets if num_buckets &amp;gt; 0 else hashed_value.
    ///             </param><param name="hash_key">
    ///               Specify the hash_key that will be used by the <c>FingerprintCat64</c>
    ///               function to combine the crosses fingerprints.
    ///             </param><param name="out_type"></param><param name="internal_type"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices: 2-D.  Indices of the concatenated <c>SparseTensor</c>.
    ///               output_values: 1-D.  Non-empty values of the concatenated or hashed
    ///               <c>SparseTensor</c>.
    ///               output_shape: 1-D.  Shape of the concatenated <c>SparseTensor</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The op takes two lists, one of 2D <c>SparseTensor</c> and one of 2D <c>Tensor</c>, each
    ///               representing features of one feature column. It outputs a 2D <c>SparseTensor</c> with
    ///               the batchwise crosses of these features.
    ///               
    ///               For example, if the inputs are
    ///               
    ///               inputs[0]: SparseTensor with shape = [2, 2]
    ///               [0, 0]: "a"
    ///               [1, 0]: "b"
    ///               [1, 1]: "c"
    ///               
    ///               inputs[1]: SparseTensor with shape = [2, 1]
    ///               [0, 0]: "d"
    ///               [1, 0]: "e"
    ///               
    ///               inputs[2]: Tensor [["f"], ["g"]]
    ///               
    ///               then the output will be
    ///               
    ///               shape = [2, 2]
    ///               [0, 0]: "a_X_d_X_f"
    ///               [1, 0]: "b_X_e_X_g"
    ///               [1, 1]: "c_X_e_X_g"
    ///               
    ///               if hashed_output=true then the output will be
    ///               
    ///               shape = [2, 2]
    ///               [0, 0]: FingerprintCat64(
    ///               Fingerprint64("f"), FingerprintCat64(
    ///               Fingerprint64("d"), Fingerprint64("a")))
    ///               [1, 0]: FingerprintCat64(
    ///               Fingerprint64("g"), FingerprintCat64(
    ///               Fingerprint64("e"), Fingerprint64("b")))
    ///               [1, 1]: FingerprintCat64(
    ///               Fingerprint64("g"), FingerprintCat64(
    ///               Fingerprint64("e"), Fingerprint64("c")))
    ///             </remarks>
    member this.SparseCross(indices : TF[], values : TF[], shapes : TF[], dense_inputs : TF[], hashed_output : Boolean, num_buckets : Int64, hash_key : Int64, out_type : TFDataType, internal_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseCross(indices |> Array.map (fun x -> x.TFOutput), values |> Array.map (fun x -> x.TFOutput), shapes |> Array.map (fun x -> x.TFOutput), dense_inputs |> Array.map (fun x -> x.TFOutput), hashed_output, num_buckets, hash_key, out_type, internal_type, operName)
    /// <summary>
    ///               Adds up a SparseTensor and a dense Tensor, using these special rules:
    ///             </summary><param name="sp_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="sp_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>sp_indices</c>.
    ///             </param><param name="sp_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="dense"><c>R</c>-D.  The dense Tensor operand.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseDenseCwiseAdd'.
    ///             </param><returns>
    ///               1-D.  The <c>N</c> values that are operated on.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               (1) Broadcasts the dense side to have the same shape as the sparse side, if
    ///               eligible;
    ///               (2) Then, only the dense values pointed to by the indices of the SparseTensor
    ///               participate in the cwise addition.
    ///               
    ///               By these rules, the result is a logical SparseTensor with exactly the same
    ///               indices and shape, but possibly with different non-zero values.  The output of
    ///               this Op is the resultant non-zero values.
    ///             </remarks>
    member this.SparseDenseCwiseAdd(sp_indices : TF, sp_values : TF, sp_shape : TF, dense : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseDenseCwiseAdd(sp_indices.TFOutput, sp_values.TFOutput, sp_shape.TFOutput, dense.TFOutput, operName))
    /// <summary>
    ///               Component-wise divides a SparseTensor by a dense Tensor.
    ///             </summary><param name="sp_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="sp_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>sp_indices</c>.
    ///             </param><param name="sp_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="dense"><c>R</c>-D.  The dense Tensor operand.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseDenseCwiseDiv'.
    ///             </param><returns>
    ///               1-D.  The <c>N</c> values that are operated on.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
    ///               the other direction.
    ///             </remarks>
    member this.SparseDenseCwiseDiv(sp_indices : TF, sp_values : TF, sp_shape : TF, dense : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseDenseCwiseDiv(sp_indices.TFOutput, sp_values.TFOutput, sp_shape.TFOutput, dense.TFOutput, operName))
    /// <summary>
    ///               Component-wise multiplies a SparseTensor by a dense Tensor.
    ///             </summary><param name="sp_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="sp_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>sp_indices</c>.
    ///             </param><param name="sp_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="dense"><c>R</c>-D.  The dense Tensor operand.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseDenseCwiseMul'.
    ///             </param><returns>
    ///               1-D.  The <c>N</c> values that are operated on.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The output locations corresponding to the implicitly zero elements in the sparse
    ///               tensor will be zero (i.e., will not take up storage space), regardless of the
    ///               contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN).
    ///               
    ///               *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
    ///               the other direction.
    ///             </remarks>
    member this.SparseDenseCwiseMul(sp_indices : TF, sp_values : TF, sp_shape : TF, dense : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseDenseCwiseMul(sp_indices.TFOutput, sp_values.TFOutput, sp_shape.TFOutput, dense.TFOutput, operName))
    /// <summary>
    ///               Fills empty rows in the input 2-D <c>SparseTensor</c> with a default value.
    ///             </summary><param name="indices">
    ///               2-D. the indices of the sparse tensor.
    ///             </param><param name="values">
    ///               1-D. the values of the sparse tensor.
    ///             </param><param name="dense_shape">
    ///               1-D. the shape of the sparse tensor.
    ///             </param><param name="default_value">
    ///               0-D. default value to insert into location <c>[row, 0, ..., 0]</c>
    ///               for rows missing from the input sparse tensor.
    ///               output indices: 2-D. the indices of the filled sparse tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseFillEmptyRows'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices:
    ///               output_values: 1-D. the values of the filled sparse tensor.
    ///               empty_row_indicator: 1-D. whether the dense row was missing in the
    ///               input sparse tensor.
    ///               reverse_index_map: 1-D. a map from the input indices to the output indices.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The input <c>SparseTensor</c> is represented via the tuple of inputs
    ///               (<c>indices</c>, <c>values</c>, <c>dense_shape</c>).  The output <c>SparseTensor</c> has the
    ///               same <c>dense_shape</c> but with indices <c>output_indices</c> and values
    ///               <c>output_values</c>.
    ///               
    ///               This op inserts a single entry for every row that doesn't have any values.
    ///               The index is created as <c>[row, 0, ..., 0]</c> and the inserted value
    ///               is <c>default_value</c>.
    ///               
    ///               For example, suppose <c>sp_input</c> has shape <c>[5, 6]</c> and non-empty values:
    ///               
    ///               [0, 1]: a
    ///               [0, 3]: b
    ///               [2, 0]: c
    ///               [3, 1]: d
    ///               
    ///               Rows 1 and 4 are empty, so the output will be of shape <c>[5, 6]</c> with values:
    ///               
    ///               [0, 1]: a
    ///               [0, 3]: b
    ///               [1, 0]: default_value
    ///               [2, 0]: c
    ///               [3, 1]: d
    ///               [4, 0]: default_value
    ///               
    ///               The output <c>SparseTensor</c> will be in row-major order and will have the
    ///               same shape as the input.
    ///               
    ///               This op also returns an indicator vector shaped <c>[dense_shape[0]]</c> such that
    ///               
    ///               empty_row_indicator[i] = True iff row i was an empty row.
    ///               
    ///               And a reverse index map vector shaped <c>[indices.shape[0]]</c> that is used during
    ///               backpropagation,
    ///               
    ///               reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :]
    ///             </remarks>
    member this.SparseFillEmptyRows(indices : TF, values : TF, dense_shape : TF, default_value : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseFillEmptyRows(indices.TFOutput, values.TFOutput, dense_shape.TFOutput, default_value.TFOutput, operName)
    /// <summary>
    ///               The gradient of SparseFillEmptyRows.
    ///             </summary><param name="reverse_index_map">
    ///               1-D.  The reverse index map from SparseFillEmptyRows.
    ///             </param><param name="grad_values">
    ///               1-D.  The gradients from backprop.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseFillEmptyRowsGrad'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               d_values: 1-D.  The backprop into values.
    ///               d_default_value: 0-D.  The backprop into default_value.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Takes vectors reverse_index_map, shaped <c>[N]</c>, and grad_values,
    ///               shaped <c>[N_full]</c>, where <c>N_full &amp;gt;= N</c> and copies data into either
    ///               <c>d_values</c> or <c>d_default_value</c>.  Here <c>d_values</c> is shaped <c>[N]</c> and
    ///               <c>d_default_value</c> is a scalar.
    ///               
    ///               d_values[j] = grad_values[reverse_index_map[j]]
    ///               d_default_value = sum_{k : 0 .. N_full - 1} (
    ///               grad_values[k] * 1{k not in reverse_index_map})
    ///             </remarks>
    member this.SparseFillEmptyRowsGrad(reverse_index_map : TF, grad_values : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.SparseFillEmptyRowsGrad(reverse_index_map.TFOutput, grad_values.TFOutput, operName)
    /// <summary>
    ///               Multiply matrix "a" by matrix "b".
    ///             </summary><param name="a"></param><param name="b"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseMatMul'.
    ///             </param><param name="transpose_a">
    ///               Optional argument
    ///             </param><param name="transpose_b">
    ///               Optional argument
    ///             </param><param name="a_is_sparse">
    ///               Optional argument
    ///             </param><param name="b_is_sparse">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The inputs must be two-dimensional matrices and the inner dimension of "a" must
    ///               match the outer dimension of "b". Both "a" and "b" must be <c>Tensor</c>s not
    ///               <c>SparseTensor</c>s.  This op is optimized for the case where at least one of "a" or
    ///               "b" is sparse, in the sense that they have a large proportion of zero values.
    ///               The breakeven for using this versus a dense matrix multiply on one platform was
    ///               30% zero values in the sparse matrix.
    ///               
    ///               The gradient computation of this operation will only take advantage of sparsity
    ///               in the input gradient when that gradient comes from a Relu.
    ///             </remarks>
    member this.SparseMatMul(a : TF, b : TF, ?transpose_a : Boolean, ?transpose_b : Boolean, ?a_is_sparse : Boolean, ?b_is_sparse : Boolean, ?operName : String) =
        let transpose_a = defaultArg (transpose_a |> Option.map Nullable) (Nullable())
        let transpose_b = defaultArg (transpose_b |> Option.map Nullable) (Nullable())
        let a_is_sparse = defaultArg (a_is_sparse |> Option.map Nullable) (Nullable())
        let b_is_sparse = defaultArg (b_is_sparse |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseMatMul(a.TFOutput, b.TFOutput, transpose_a, transpose_b, a_is_sparse, b_is_sparse, operName))
    /// <summary>
    ///               Computes the max of elements across dimensions of a SparseTensor.
    ///             </summary><param name="input_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="input_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>input_indices</c>.
    ///             </param><param name="input_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="reduction_axes">
    ///               1-D.  Length-<c>K</c> vector containing the reduction axes.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseReduceMax'.
    ///             </param><param name="keep_dims">
    ///               Optional argument
    ///               If true, retain reduced dimensions with length 1.
    ///             </param><returns><c>R-K</c>-D.  The reduced Tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This Op takes a SparseTensor and is the sparse counterpart to
    ///               <c>tf.reduce_max()</c>.  In particular, this Op also returns a dense <c>Tensor</c>
    ///               instead of a sparse one.
    ///               
    ///               Reduces <c>sp_input</c> along the dimensions given in <c>reduction_axes</c>.  Unless
    ///               <c>keep_dims</c> is true, the rank of the tensor is reduced by 1 for each entry in
    ///               <c>reduction_axes</c>. If <c>keep_dims</c> is true, the reduced dimensions are retained
    ///               with length 1.
    ///               
    ///               If <c>reduction_axes</c> has no entries, all dimensions are reduced, and a tensor
    ///               with a single element is returned.  Additionally, the axes can be negative,
    ///               which are interpreted according to the indexing rules in Python.
    ///             </remarks>
    member this.SparseReduceMax(input_indices : TF, input_values : TF, input_shape : TF, reduction_axes : TF, ?keep_dims : Boolean, ?operName : String) =
        let keep_dims = defaultArg (keep_dims |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseReduceMax(input_indices.TFOutput, input_values.TFOutput, input_shape.TFOutput, reduction_axes.TFOutput, keep_dims, operName))
    /// <summary>
    ///               Computes the max of elements across dimensions of a SparseTensor.
    ///             </summary><param name="input_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="input_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>input_indices</c>.
    ///             </param><param name="input_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="reduction_axes">
    ///               1-D.  Length-<c>K</c> vector containing the reduction axes.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseReduceMaxSparse'.
    ///             </param><param name="keep_dims">
    ///               Optional argument
    ///               If true, retain reduced dimensions with length 1.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices:
    ///               output_values:
    ///               output_shape:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This Op takes a SparseTensor and is the sparse counterpart to
    ///               <c>tf.reduce_max()</c>.  In contrast to SparseReduceMax, this Op returns a
    ///               SparseTensor.
    ///               
    ///               Reduces <c>sp_input</c> along the dimensions given in <c>reduction_axes</c>.  Unless
    ///               <c>keep_dims</c> is true, the rank of the tensor is reduced by 1 for each entry in
    ///               <c>reduction_axes</c>. If <c>keep_dims</c> is true, the reduced dimensions are retained
    ///               with length 1.
    ///               
    ///               If <c>reduction_axes</c> has no entries, all dimensions are reduced, and a tensor
    ///               with a single element is returned.  Additionally, the axes can be negative,
    ///               which are interpreted according to the indexing rules in Python.
    ///             </remarks>
    member this.SparseReduceMaxSparse(input_indices : TF, input_values : TF, input_shape : TF, reduction_axes : TF, ?keep_dims : Boolean, ?operName : String) =
        let keep_dims = defaultArg (keep_dims |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SparseReduceMaxSparse(input_indices.TFOutput, input_values.TFOutput, input_shape.TFOutput, reduction_axes.TFOutput, keep_dims, operName)
    /// <summary>
    ///               Computes the sum of elements across dimensions of a SparseTensor.
    ///             </summary><param name="input_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="input_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>input_indices</c>.
    ///             </param><param name="input_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="reduction_axes">
    ///               1-D.  Length-<c>K</c> vector containing the reduction axes.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseReduceSum'.
    ///             </param><param name="keep_dims">
    ///               Optional argument
    ///               If true, retain reduced dimensions with length 1.
    ///             </param><returns><c>R-K</c>-D.  The reduced Tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This Op takes a SparseTensor and is the sparse counterpart to
    ///               <c>tf.reduce_sum()</c>.  In particular, this Op also returns a dense <c>Tensor</c>
    ///               instead of a sparse one.
    ///               
    ///               Reduces <c>sp_input</c> along the dimensions given in <c>reduction_axes</c>.  Unless
    ///               <c>keep_dims</c> is true, the rank of the tensor is reduced by 1 for each entry in
    ///               <c>reduction_axes</c>. If <c>keep_dims</c> is true, the reduced dimensions are retained
    ///               with length 1.
    ///               
    ///               If <c>reduction_axes</c> has no entries, all dimensions are reduced, and a tensor
    ///               with a single element is returned.  Additionally, the axes can be negative,
    ///               which are interpreted according to the indexing rules in Python.
    ///             </remarks>
    member this.SparseReduceSum(input_indices : TF, input_values : TF, input_shape : TF, reduction_axes : TF, ?keep_dims : Boolean, ?operName : String) =
        let keep_dims = defaultArg (keep_dims |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.SparseReduceSum(input_indices.TFOutput, input_values.TFOutput, input_shape.TFOutput, reduction_axes.TFOutput, keep_dims, operName))
    /// <summary>
    ///               Computes the sum of elements across dimensions of a SparseTensor.
    ///             </summary><param name="input_indices">
    ///               2-D.  <c>N x R</c> matrix with the indices of non-empty values in a
    ///               SparseTensor, possibly not in canonical ordering.
    ///             </param><param name="input_values">
    ///               1-D.  <c>N</c> non-empty values corresponding to <c>input_indices</c>.
    ///             </param><param name="input_shape">
    ///               1-D.  Shape of the input SparseTensor.
    ///             </param><param name="reduction_axes">
    ///               1-D.  Length-<c>K</c> vector containing the reduction axes.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'SparseReduceSumSparse'.
    ///             </param><param name="keep_dims">
    ///               Optional argument
    ///               If true, retain reduced dimensions with length 1.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_indices:
    ///               output_values:
    ///               output_shape:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This Op takes a SparseTensor and is the sparse counterpart to
    ///               <c>tf.reduce_sum()</c>.  In contrast to SparseReduceSum, this Op returns a
    ///               SparseTensor.
    ///               
    ///               Reduces <c>sp_input</c> along the dimensions given in <c>reduction_axes</c>.  Unless
    ///               <c>keep_dims</c> is true, the rank of the tensor is reduced by 1 for each entry in
    ///               <c>reduction_axes</c>. If <c>keep_dims</c> is true, the reduced dimensions are retained
    ///               with length 1.
    ///               
    ///               If <c>reduction_axes</c> has no entries, all dimensions are reduced, and a tensor
    ///               with a single element is returned.  Additionally, the axes can be negative,
    ///               which are interpreted according to the indexing rules in Python.
    ///             </remarks>
    member this.SparseReduceSumSparse(input_indices : TF, input_values : TF, input_shape : TF, reduction_axes : TF, ?keep_dims : Boolean, ?operName : String) =
        let keep_dims = defaultArg (keep_dims |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.SparseReduceSumSparse(input_indices.TFOutput, input_values.TFOutput, input_shape.TFOutput, reduction_axes.TFOutput, keep_dims, operName)
    /// <summary>
    ///               Returns x + y element-wise, working on quantized buffers.
    ///             </summary><param name="x"></param><param name="y"></param><param name="min_x">
    ///               The float value that the lowest quantized <c>x</c> value represents.
    ///             </param><param name="max_x">
    ///               The float value that the highest quantized <c>x</c> value represents.
    ///             </param><param name="min_y">
    ///               The float value that the lowest quantized <c>y</c> value represents.
    ///             </param><param name="max_y">
    ///               The float value that the highest quantized <c>y</c> value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedAdd'.
    ///             </param><param name="Toutput">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               z:
    ///               min_z: The float value that the lowest quantized output value represents.
    ///               max_z: The float value that the highest quantized output value represents.
    ///               
    ///               *NOTE*: <c>QuantizedAdd</c> supports limited forms of broadcasting. More about
    ///               broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedAdd(x : TF, y : TF, min_x : TF, max_x : TF, min_y : TF, max_y : TF, ?Toutput : TFDataType, ?operName : String) =
        let Toutput = defaultArg (Toutput |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedAdd(x.TFOutput, y.TFOutput, min_x.TFOutput, max_x.TFOutput, min_y.TFOutput, max_y.TFOutput, Toutput, operName)
    /// <summary>
    ///               Produces the average pool of the input tensor for quantized types.
    ///             </summary><param name="input">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="min_input">
    ///               The float value that the lowest quantized input value represents.
    ///             </param><param name="max_input">
    ///               The float value that the highest quantized input value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedAvgPool'.
    ///             </param><param name="ksize">
    ///               The size of the window for each dimension of the input tensor.
    ///               The length must be 4 to match the number of dimensions of the input.
    ///             </param><param name="strides">
    ///               The stride of the sliding window for each dimension of the input
    ///               tensor.  The length must be 4 to match the number of dimensions of the input.
    ///             </param><param name="padding">
    ///               The type of padding algorithm to use.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               min_output: The float value that the lowest quantized output value represents.
    ///               max_output: The float value that the highest quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedAvgPool(input : TF, min_input : TF, max_input : TF, ksize : Int64[], strides : Int64[], padding : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizedAvgPool(input.TFOutput, min_input.TFOutput, max_input.TFOutput, ksize, strides, padding, operName)
    /// <summary>
    ///               Quantized Batch normalization.
    ///             </summary><param name="t">
    ///               A 4D input Tensor.
    ///             </param><param name="t_min">
    ///               The value represented by the lowest quantized input.
    ///             </param><param name="t_max">
    ///               The value represented by the highest quantized input.
    ///             </param><param name="m">
    ///               A 1D mean Tensor with size matching the last dimension of t.
    ///               This is the first output from tf.nn.moments,
    ///               or a saved moving average thereof.
    ///             </param><param name="m_min">
    ///               The value represented by the lowest quantized mean.
    ///             </param><param name="m_max">
    ///               The value represented by the highest quantized mean.
    ///             </param><param name="v">
    ///               A 1D variance Tensor with size matching the last dimension of t.
    ///               This is the second output from tf.nn.moments,
    ///               or a saved moving average thereof.
    ///             </param><param name="v_min">
    ///               The value represented by the lowest quantized variance.
    ///             </param><param name="v_max">
    ///               The value represented by the highest quantized variance.
    ///             </param><param name="beta">
    ///               A 1D beta Tensor with size matching the last dimension of t.
    ///               An offset to be added to the normalized tensor.
    ///             </param><param name="beta_min">
    ///               The value represented by the lowest quantized offset.
    ///             </param><param name="beta_max">
    ///               The value represented by the highest quantized offset.
    ///             </param><param name="gamma">
    ///               A 1D gamma Tensor with size matching the last dimension of t.
    ///               If "scale_after_normalization" is true, this tensor will be multiplied
    ///               with the normalized tensor.
    ///             </param><param name="gamma_min">
    ///               The value represented by the lowest quantized gamma.
    ///             </param><param name="gamma_max">
    ///               The value represented by the highest quantized gamma.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedBatchNormWithGlobalNormalization'.
    ///             </param><param name="out_type"></param><param name="variance_epsilon">
    ///               A small float number to avoid dividing by 0.
    ///             </param><param name="scale_after_normalization">
    ///               A bool indicating whether the resulted tensor
    ///               needs to be multiplied with gamma.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               result:
    ///               result_min:
    ///               result_max:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               This op is deprecated and will be removed in the future. Prefer
    ///               <c>tf.nn.batch_normalization</c>.
    ///             </remarks>
    member this.QuantizedBatchNormWithGlobalNormalization(t : TF, t_min : TF, t_max : TF, m : TF, m_min : TF, m_max : TF, v : TF, v_min : TF, v_max : TF, beta : TF, beta_min : TF, beta_max : TF, gamma : TF, gamma_min : TF, gamma_max : TF, out_type : TFDataType, variance_epsilon : Single, scale_after_normalization : Boolean, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizedBatchNormWithGlobalNormalization(t.TFOutput, t_min.TFOutput, t_max.TFOutput, m.TFOutput, m_min.TFOutput, m_max.TFOutput, v.TFOutput, v_min.TFOutput, v_max.TFOutput, beta.TFOutput, beta_min.TFOutput, beta_max.TFOutput, gamma.TFOutput, gamma_min.TFOutput, gamma_max.TFOutput, out_type, variance_epsilon, scale_after_normalization, operName)
    /// <summary>
    ///               Adds Tensor 'bias' to Tensor 'input' for Quantized types.
    ///             </summary><param name="input"></param><param name="bias">
    ///               A 1D bias Tensor with size matching the last dimension of 'input'.
    ///             </param><param name="min_input">
    ///               The float value that the lowest quantized input value represents.
    ///             </param><param name="max_input">
    ///               The float value that the highest quantized input value represents.
    ///             </param><param name="min_bias">
    ///               The float value that the lowest quantized bias value represents.
    ///             </param><param name="max_bias">
    ///               The float value that the highest quantized bias value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedBiasAdd'.
    ///             </param><param name="out_type"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               min_out: The float value that the lowest quantized output value represents.
    ///               max_out: The float value that the highest quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
    ///             </remarks>
    member this.QuantizedBiasAdd(input : TF, bias : TF, min_input : TF, max_input : TF, min_bias : TF, max_bias : TF, out_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizedBiasAdd(input.TFOutput, bias.TFOutput, min_input.TFOutput, max_input.TFOutput, min_bias.TFOutput, max_bias.TFOutput, out_type, operName)
    /// <summary>
    ///               Concatenates quantized tensors along one dimension.
    ///             </summary><param name="concat_dim">
    ///               0-D.  The dimension along which to concatenate.  Must be in the
    ///               range [0, rank(values)).
    ///             </param><param name="values">
    ///               The <c>N</c> Tensors to concatenate. Their ranks and types must match,
    ///               and their sizes must match in all dimensions except <c>concat_dim</c>.
    ///             </param><param name="input_mins">
    ///               The minimum scalar values for each of the input tensors.
    ///             </param><param name="input_maxes">
    ///               The maximum scalar values for each of the input tensors.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedConcat'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output: A <c>Tensor</c> with the concatenation of values stacked along the
    ///               <c>concat_dim</c> dimension.  This tensor's shape matches that of <c>values</c> except
    ///               in <c>concat_dim</c> where it has the sum of the sizes.
    ///               output_min: The float value that the minimum quantized output value represents.
    ///               output_max: The float value that the maximum quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedConcat(concat_dim : TF, values : TF[], input_mins : TF[], input_maxes : TF[], ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizedConcat(concat_dim.TFOutput, values |> Array.map (fun x -> x.TFOutput), input_mins |> Array.map (fun x -> x.TFOutput), input_maxes |> Array.map (fun x -> x.TFOutput), operName)
    /// <summary>
    ///               Computes a 2D convolution given quantized 4D input and filter tensors.
    ///             </summary><param name="input"></param><param name="filter">
    ///               filter's input_depth dimension must match input's depth dimensions.
    ///             </param><param name="min_input">
    ///               The float value that the lowest quantized input value represents.
    ///             </param><param name="max_input">
    ///               The float value that the highest quantized input value represents.
    ///             </param><param name="min_filter">
    ///               The float value that the lowest quantized filter value represents.
    ///             </param><param name="max_filter">
    ///               The float value that the highest quantized filter value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedConv2D'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><param name="dilations">
    ///               Optional argument
    ///               1-D tensor of length 4.  The dilation factor for each dimension of
    ///               <c>input</c>. If set to k &amp;gt; 1, there will be k-1 skipped cells between each
    ///               filter element on that dimension. The dimension order is determined by the
    ///               value of <c>data_format</c>, see above for details. Dilations in the batch and
    ///               depth dimensions must be 1.
    ///             </param><param name="strides">
    ///               The stride of the sliding window for each dimension of the input
    ///               tensor.
    ///             </param><param name="padding">
    ///               The type of padding algorithm to use.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               min_output: The float value that the lowest quantized output value represents.
    ///               max_output: The float value that the highest quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The inputs are quantized tensors where the lowest value represents the real
    ///               number of the associated minimum, and the highest represents the maximum.
    ///               This means that you can only interpret the quantized output in the same way, by
    ///               taking the returned minimum and maximum values into account.
    ///             </remarks>
    member this.QuantizedConv2D(input : TF, filter : TF, min_input : TF, max_input : TF, min_filter : TF, max_filter : TF, strides : Int64[], padding : String, ?out_type : TFDataType, ?dilations : Int64[], ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let dilations = defaultArg dilations null
        let operName = defaultArg operName null
        this.TFGraph.QuantizedConv2D(input.TFOutput, filter.TFOutput, min_input.TFOutput, max_input.TFOutput, min_filter.TFOutput, max_filter.TFOutput, strides, padding, out_type, dilations, operName)
    /// <summary>
    ///               Quantized Instance normalization.
    ///             </summary><param name="x">
    ///               A 4D input Tensor.
    ///             </param><param name="x_min">
    ///               The value represented by the lowest quantized input.
    ///             </param><param name="x_max">
    ///               The value represented by the highest quantized input.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedInstanceNorm'.
    ///             </param><param name="output_range_given">
    ///               Optional argument
    ///               If True, <c>given_y_min</c> and <c>given_y_min</c>
    ///               and <c>given_y_max</c> are used as the output range. Otherwise,
    ///               the implementation computes the output range.
    ///             </param><param name="given_y_min">
    ///               Optional argument
    ///               Output in <c>y_min</c> if <c>output_range_given</c> is True.
    ///             </param><param name="given_y_max">
    ///               Optional argument
    ///               Output in <c>y_max</c> if <c>output_range_given</c> is True.
    ///             </param><param name="variance_epsilon">
    ///               Optional argument
    ///               A small float number to avoid dividing by 0.
    ///             </param><param name="min_separation">
    ///               Optional argument
    ///               Minimum value of <c>y_max - y_min</c></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               y: A 4D Tensor.
    ///               y_min: The value represented by the lowest quantized output.
    ///               y_max: The value represented by the highest quantized output.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedInstanceNorm(x : TF, x_min : TF, x_max : TF, ?output_range_given : Boolean, ?given_y_min : Single, ?given_y_max : Single, ?variance_epsilon : Single, ?min_separation : Single, ?operName : String) =
        let output_range_given = defaultArg (output_range_given |> Option.map Nullable) (Nullable())
        let given_y_min = defaultArg (given_y_min |> Option.map Nullable) (Nullable())
        let given_y_max = defaultArg (given_y_max |> Option.map Nullable) (Nullable())
        let variance_epsilon = defaultArg (variance_epsilon |> Option.map Nullable) (Nullable())
        let min_separation = defaultArg (min_separation |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedInstanceNorm(x.TFOutput, x_min.TFOutput, x_max.TFOutput, output_range_given, given_y_min, given_y_max, variance_epsilon, min_separation, operName)
    /// <summary>
    ///               Perform a quantized matrix multiplication of  <c>a</c> by the matrix <c>b</c>.
    ///             </summary><param name="a">
    ///               Must be a two-dimensional tensor.
    ///             </param><param name="b">
    ///               Must be a two-dimensional tensor.
    ///             </param><param name="min_a">
    ///               The float value that the lowest quantized <c>a</c> value represents.
    ///             </param><param name="max_a">
    ///               The float value that the highest quantized <c>a</c> value represents.
    ///             </param><param name="min_b">
    ///               The float value that the lowest quantized <c>b</c> value represents.
    ///             </param><param name="max_b">
    ///               The float value that the highest quantized <c>b</c> value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedMatMul'.
    ///             </param><param name="Toutput">
    ///               Optional argument
    ///             </param><param name="transpose_a">
    ///               Optional argument
    ///               If true, <c>a</c> is transposed before multiplication.
    ///             </param><param name="transpose_b">
    ///               Optional argument
    ///               If true, <c>b</c> is transposed before multiplication.
    ///             </param><param name="Tactivation">
    ///               Optional argument
    ///               The type of output produced by activation function
    ///               following this operation.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               min_out: The float value that the lowest quantized output value represents.
    ///               max_out: The float value that the highest quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               The inputs must be two-dimensional matrices and the inner dimension of
    ///               <c>a</c> (after being transposed if <c>transpose_a</c> is non-zero) must match the
    ///               outer dimension of <c>b</c> (after being transposed if <c>transposed_b</c> is
    ///               non-zero).
    ///             </remarks>
    member this.QuantizedMatMul(a : TF, b : TF, min_a : TF, max_a : TF, min_b : TF, max_b : TF, ?Toutput : TFDataType, ?transpose_a : Boolean, ?transpose_b : Boolean, ?Tactivation : TFDataType, ?operName : String) =
        let Toutput = defaultArg (Toutput |> Option.map Nullable) (Nullable())
        let transpose_a = defaultArg (transpose_a |> Option.map Nullable) (Nullable())
        let transpose_b = defaultArg (transpose_b |> Option.map Nullable) (Nullable())
        let Tactivation = defaultArg (Tactivation |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedMatMul(a.TFOutput, b.TFOutput, min_a.TFOutput, max_a.TFOutput, min_b.TFOutput, max_b.TFOutput, Toutput, transpose_a, transpose_b, Tactivation, operName)
    /// <summary>
    ///               Produces the max pool of the input tensor for quantized types.
    ///             </summary><param name="input">
    ///               The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.
    ///             </param><param name="min_input">
    ///               The float value that the lowest quantized input value represents.
    ///             </param><param name="max_input">
    ///               The float value that the highest quantized input value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedMaxPool'.
    ///             </param><param name="ksize">
    ///               The size of the window for each dimension of the input tensor.
    ///               The length must be 4 to match the number of dimensions of the input.
    ///             </param><param name="strides">
    ///               The stride of the sliding window for each dimension of the input
    ///               tensor. The length must be 4 to match the number of dimensions of the input.
    ///             </param><param name="padding">
    ///               The type of padding algorithm to use.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               min_output: The float value that the lowest quantized output value represents.
    ///               max_output: The float value that the highest quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedMaxPool(input : TF, min_input : TF, max_input : TF, ksize : Int64[], strides : Int64[], padding : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizedMaxPool(input.TFOutput, min_input.TFOutput, max_input.TFOutput, ksize, strides, padding, operName)
    /// <summary>
    ///               Returns x * y element-wise, working on quantized buffers.
    ///             </summary><param name="x"></param><param name="y"></param><param name="min_x">
    ///               The float value that the lowest quantized <c>x</c> value represents.
    ///             </param><param name="max_x">
    ///               The float value that the highest quantized <c>x</c> value represents.
    ///             </param><param name="min_y">
    ///               The float value that the lowest quantized <c>y</c> value represents.
    ///             </param><param name="max_y">
    ///               The float value that the highest quantized <c>y</c> value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedMul'.
    ///             </param><param name="Toutput">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               z:
    ///               min_z: The float value that the lowest quantized output value represents.
    ///               max_z: The float value that the highest quantized output value represents.
    ///               
    ///               *NOTE*: <c>QuantizedMul</c> supports limited forms of broadcasting. More about
    ///               broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedMul(x : TF, y : TF, min_x : TF, max_x : TF, min_y : TF, max_y : TF, ?Toutput : TFDataType, ?operName : String) =
        let Toutput = defaultArg (Toutput |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedMul(x.TFOutput, y.TFOutput, min_x.TFOutput, max_x.TFOutput, min_y.TFOutput, max_y.TFOutput, Toutput, operName)
    /// <summary>
    ///               Convert the quantized 'input' tensor into a lower-precision 'output', using the
    ///             </summary><param name="input"></param><param name="input_min">
    ///               The float value that the minimum quantized input value represents.
    ///             </param><param name="input_max">
    ///               The float value that the maximum quantized input value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizeDownAndShrinkRange'.
    ///             </param><param name="out_type">
    ///               The type of the output. Should be a lower bit depth than Tinput.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               output_min: The float value that the minimum quantized output value represents.
    ///               output_max: The float value that the maximum quantized output value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               actual distribution of the values to maximize the usage of the lower bit depth
    ///               and adjusting the output min and max ranges accordingly.
    ///               
    ///               [input_min, input_max] are scalar floats that specify the range for the float
    ///               interpretation of the 'input' data. For example, if input_min is -1.0f and
    ///               input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
    ///               value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
    ///               
    ///               This operator tries to squeeze as much precision as possible into an output with
    ///               a lower bit depth by calculating the actual min and max values found in the
    ///               data. For example, maybe that quint16 input has no values lower than 16,384 and
    ///               none higher than 49,152. That means only half the range is actually needed, all
    ///               the float interpretations are between -0.5f and 0.5f, so if we want to compress
    ///               the data into a quint8 output, we can use that range rather than the theoretical
    ///               -1.0f to 1.0f that is suggested by the input min and max.
    ///               
    ///               In practice, this is most useful for taking output from operations like
    ///               QuantizedMatMul that can produce higher bit-depth outputs than their inputs and
    ///               may have large potential output ranges, but in practice have a distribution of
    ///               input values that only uses a small fraction of the possible range. By feeding
    ///               that output into this operator, we can reduce it from 32 bits down to 8 with
    ///               minimal loss of accuracy.
    ///             </remarks>
    member this.QuantizeDownAndShrinkRange(input : TF, input_min : TF, input_max : TF, out_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizeDownAndShrinkRange(input.TFOutput, input_min.TFOutput, input_max.TFOutput, out_type, operName)
    /// <summary>
    ///               Computes Quantized Rectified Linear: <c>max(features, 0)</c></summary><param name="features"></param><param name="min_features">
    ///               The float value that the lowest quantized value represents.
    ///             </param><param name="max_features">
    ///               The float value that the highest quantized value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedRelu'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               activations: Has the same output shape as "features".
    ///               min_activations: The float value that the lowest quantized value represents.
    ///               max_activations: The float value that the highest quantized value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedRelu(features : TF, min_features : TF, max_features : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedRelu(features.TFOutput, min_features.TFOutput, max_features.TFOutput, out_type, operName)
    /// <summary>
    ///               Computes Quantized Rectified Linear 6: <c>min(max(features, 0), 6)</c></summary><param name="features"></param><param name="min_features">
    ///               The float value that the lowest quantized value represents.
    ///             </param><param name="max_features">
    ///               The float value that the highest quantized value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedRelu6'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               activations: Has the same output shape as "features".
    ///               min_activations: The float value that the lowest quantized value represents.
    ///               max_activations: The float value that the highest quantized value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedRelu6(features : TF, min_features : TF, max_features : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedRelu6(features.TFOutput, min_features.TFOutput, max_features.TFOutput, out_type, operName)
    /// <summary>
    ///               Computes Quantized Rectified Linear X: <c>min(max(features, 0), max_value)</c></summary><param name="features"></param><param name="max_value"></param><param name="min_features">
    ///               The float value that the lowest quantized value represents.
    ///             </param><param name="max_features">
    ///               The float value that the highest quantized value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedReluX'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               activations: Has the same output shape as "features".
    ///               min_activations: The float value that the lowest quantized value represents.
    ///               max_activations: The float value that the highest quantized value represents.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns>
    member this.QuantizedReluX(features : TF, max_value : TF, min_features : TF, max_features : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedReluX(features.TFOutput, max_value.TFOutput, min_features.TFOutput, max_features.TFOutput, out_type, operName)
    member this.QuantizedReshape(tensor : TF, shape : TF, input_min : TF, input_max : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.QuantizedReshape(tensor.TFOutput, shape.TFOutput, input_min.TFOutput, input_max.TFOutput, operName)
    /// <summary>
    ///               Resize quantized <c>images</c> to <c>size</c> using quantized bilinear interpolation.
    ///             </summary><param name="images">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="size">
    ///               = A 1-D int32 Tensor of 2 elements: <c>new_height, new_width</c>.  The
    ///               new size for the images.
    ///             </param><param name="min"></param><param name="max"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizedResizeBilinear'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and output tensors are
    ///               aligned, preserving the values at the corner pixels. Defaults to false.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               resized_images: 4-D with shape
    ///               <c>[batch, new_height, new_width, channels]</c>.
    ///               out_min:
    ///               out_max:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Input images and output images must be quantized types.
    ///             </remarks>
    member this.QuantizedResizeBilinear(images : TF, size : TF, min : TF, max : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QuantizedResizeBilinear(images.TFOutput, size.TFOutput, min.TFOutput, max.TFOutput, align_corners, operName)
    /// <summary>
    ///               Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.
    ///             </summary><param name="input"></param><param name="min_range">
    ///               The minimum scalar value possibly produced for the input.
    ///             </param><param name="max_range">
    ///               The maximum scalar value possibly produced for the input.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QuantizeV2'.
    ///             </param><param name="mode">
    ///               Optional argument
    ///             </param><param name="round_mode">
    ///               Optional argument
    ///             </param><param name="T"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output: The quantized data produced from the float input.
    ///               output_min: The actual minimum scalar value used for the output.
    ///               output_max: The actual maximum scalar value used for the output.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               [min_range, max_range] are scalar floats that specify the range for
    ///               the 'input' data. The 'mode' attribute controls exactly which calculations are
    ///               used to convert the float values to their quantized equivalents.  The
    ///               'round_mode' attribute controls which rounding tie-breaking algorithm is used
    ///               when rounding float values to their quantized equivalents.
    ///               
    ///               In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
    ///               
    ///                <code>
    ///               out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
    ///               if T == qint8: out[i] -= (range(T) + 1) / 2.0
    ///                </code>
    ///               
    ///               here <c>range(T) = numeric_limits&amp;lt;T&amp;gt;::max() - numeric_limits&amp;lt;T&amp;gt;::min()</c>
    ///               
    ///               *MIN_COMBINED Mode Example*
    ///               
    ///               Assume the input is type float and has a possible range of [0.0, 6.0] and the
    ///               output type is quint8 ([0, 255]). The min_range and max_range values should be
    ///               specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
    ///               value of the input by 255/6 and cast to quint8.
    ///               
    ///               If the output type was qint8 ([-128, 127]), the operation will additionally
    ///               subtract each value by 128 prior to casting, so that the range of values aligns
    ///               with the range of qint8.
    ///               
    ///               If the mode is 'MIN_FIRST', then this approach is used:
    ///               
    ///                <code>
    ///               num_discrete_values = 1 &amp;lt;&amp;lt; (# of bits in T)
    ///               range_adjust = num_discrete_values / (num_discrete_values - 1)
    ///               range = (range_max - range_min) * range_adjust
    ///               range_scale = num_discrete_values / range
    ///               quantized = round(input * range_scale) - round(range_min * range_scale) +
    ///               numeric_limits&amp;lt;T&amp;gt;::min()
    ///               quantized = max(quantized, numeric_limits&amp;lt;T&amp;gt;::min())
    ///               quantized = min(quantized, numeric_limits&amp;lt;T&amp;gt;::max())
    ///                </code>
    ///               
    ///               The biggest difference between this and MIN_COMBINED is that the minimum range
    ///               is rounded first, before it's subtracted from the rounded value. With
    ///               MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
    ///               and dequantizing will introduce a larger and larger error.
    ///               
    ///               *SCALED mode Example*
    ///               
    ///               <c>SCALED</c> mode matches the quantization approach used in
    ///               <c>QuantizeAndDequantize{V2|V3}</c>.
    ///               
    ///               If the mode is <c>SCALED</c>, we do not use the full range of the output type,
    ///               choosing to elide the lowest possible value for symmetry (e.g., output range is
    ///               -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
    ///               0.
    ///               
    ///               We first find the range of values in our tensor. The
    ///               range we use is always centered on 0, so we find m such that
    ///               
    ///                <code>
    ///               m = max(abs(input_min), abs(input_max))
    ///                </code>
    ///               
    ///               Our input tensor range is then <c>[-m, m]</c>.
    ///               
    ///               Next, we choose our fixed-point quantization buckets, <c>[min_fixed, max_fixed]</c>.
    ///               If T is signed, this is
    ///               
    ///                <code>
    ///               num_bits = sizeof(T) * 8
    ///               [min_fixed, max_fixed] =
    ///               [-(1 &amp;lt;&amp;lt; (num_bits - 1) - 1), (1 &amp;lt;&amp;lt; (num_bits - 1)) - 1]
    ///                </code>
    ///               
    ///               Otherwise, if T is unsigned, the fixed-point range is
    ///               
    ///                <code>
    ///               [min_fixed, max_fixed] = [0, (1 &amp;lt;&amp;lt; num_bits) - 1]
    ///                </code>
    ///               
    ///               From this we compute our scaling factor, s:
    ///               
    ///                <code>
    ///               s = (max_fixed - min_fixed) / (2 * m)
    ///                </code>
    ///               
    ///               Now we can quantize the elements of our tensor:
    ///               
    ///                <code>
    ///               result = round(input * s)
    ///                </code>
    ///               
    ///               One thing to watch out for is that the operator may choose to adjust the
    ///               requested minimum and maximum values slightly during the quantization process,
    ///               so you should always use the output ports as the range for further calculations.
    ///               For example, if the requested minimum and maximum values are close to equal,
    ///               they will be separated by a small epsilon value to prevent ill-formed quantized
    ///               buffers from being created. Otherwise, you can end up with buffers where all the
    ///               quantized values map to the same float value, which causes problems for
    ///               operations that have to perform further calculations on them.
    ///             </remarks>
    member this.QuantizeV2(input : TF, min_range : TF, max_range : TF, T : TFDataType, ?mode : String, ?round_mode : String, ?operName : String) =
        let mode = defaultArg mode null
        let round_mode = defaultArg round_mode null
        let operName = defaultArg operName null
        this.TFGraph.QuantizeV2(input.TFOutput, min_range.TFOutput, max_range.TFOutput, T, mode, round_mode, operName)
    /// <summary>
    ///               Closes the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueClose'.
    ///             </param><param name="cancel_pending_enqueues">
    ///               Optional argument
    ///               If true, all pending enqueue requests that are
    ///               blocked on the given queue will be canceled.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation signals that no more elements will be enqueued in the
    ///               given queue. Subsequent Enqueue(Many) operations will fail.
    ///               Subsequent Dequeue(Many) operations will continue to succeed if
    ///               sufficient elements remain in the queue. Subsequent Dequeue(Many)
    ///               operations that would block will fail immediately.
    ///             </remarks>
    member this.QueueClose(handle : TF, ?cancel_pending_enqueues : Boolean, ?operName : String) =
        let cancel_pending_enqueues = defaultArg (cancel_pending_enqueues |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueClose(handle.TFOutput, cancel_pending_enqueues, operName)
    /// <summary>
    ///               Closes the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueCloseV2'.
    ///             </param><param name="cancel_pending_enqueues">
    ///               Optional argument
    ///               If true, all pending enqueue requests that are
    ///               blocked on the given queue will be canceled.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation signals that no more elements will be enqueued in the
    ///               given queue. Subsequent Enqueue(Many) operations will fail.
    ///               Subsequent Dequeue(Many) operations will continue to succeed if
    ///               sufficient elements remain in the queue. Subsequent Dequeue(Many)
    ///               operations that would block will fail immediately.
    ///             </remarks>
    member this.QueueCloseV2(handle : TF, ?cancel_pending_enqueues : Boolean, ?operName : String) =
        let cancel_pending_enqueues = defaultArg (cancel_pending_enqueues |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueCloseV2(handle.TFOutput, cancel_pending_enqueues, operName)
    /// <summary>
    ///               Dequeues a tuple of one or more tensors from the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueDequeue'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue is empty, this operation will block for up to
    ///               timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><param name="component_types">
    ///               The type of each component in a tuple.
    ///             </param><returns>
    ///               One or more tensors that were dequeued as a tuple.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation has k outputs, where k is the number of components
    ///               in the tuples stored in the given queue, and output i is the ith
    ///               component of the dequeued tuple.
    ///               
    ///               N.B. If the queue is empty, this operation will block until an element
    ///               has been dequeued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueDequeue(handle : TF, component_types : TFDataType[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueDequeue(handle.TFOutput, component_types, timeout_ms, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Dequeues <c>n</c> tuples of one or more tensors from the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="n">
    ///               The number of tuples to dequeue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueDequeueMany'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue has fewer than n elements, this operation
    ///               will block for up to timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><param name="component_types">
    ///               The type of each component in a tuple.
    ///             </param><returns>
    ///               One or more tensors that were dequeued as a tuple.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               If the queue is closed and there are fewer than <c>n</c> elements, then an
    ///               OutOfRange error is returned.
    ///               
    ///               This operation concatenates queue-element component tensors along the
    ///               0th dimension to make a single component tensor.  All of the components
    ///               in the dequeued tuple will have size <c>n</c> in the 0th dimension.
    ///               
    ///               This operation has <c>k</c> outputs, where <c>k</c> is the number of components in
    ///               the tuples stored in the given queue, and output <c>i</c> is the ith
    ///               component of the dequeued tuple.
    ///               
    ///               N.B. If the queue is empty, this operation will block until <c>n</c> elements
    ///               have been dequeued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueDequeueMany(handle : TF, n : TF, component_types : TFDataType[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueDequeueMany(handle.TFOutput, n.TFOutput, component_types, timeout_ms, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Dequeues <c>n</c> tuples of one or more tensors from the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="n">
    ///               The number of tuples to dequeue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueDequeueManyV2'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue has fewer than n elements, this operation
    ///               will block for up to timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><param name="component_types">
    ///               The type of each component in a tuple.
    ///             </param><returns>
    ///               One or more tensors that were dequeued as a tuple.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               If the queue is closed and there are fewer than <c>n</c> elements, then an
    ///               OutOfRange error is returned.
    ///               
    ///               This operation concatenates queue-element component tensors along the
    ///               0th dimension to make a single component tensor.  All of the components
    ///               in the dequeued tuple will have size <c>n</c> in the 0th dimension.
    ///               
    ///               This operation has <c>k</c> outputs, where <c>k</c> is the number of components in
    ///               the tuples stored in the given queue, and output <c>i</c> is the ith
    ///               component of the dequeued tuple.
    ///               
    ///               N.B. If the queue is empty, this operation will block until <c>n</c> elements
    ///               have been dequeued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueDequeueManyV2(handle : TF, n : TF, component_types : TFDataType[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueDequeueManyV2(handle.TFOutput, n.TFOutput, component_types, timeout_ms, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Dequeues <c>n</c> tuples of one or more tensors from the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="n">
    ///               The number of tuples to dequeue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueDequeueUpTo'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue has fewer than n elements, this operation
    ///               will block for up to timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><param name="component_types">
    ///               The type of each component in a tuple.
    ///             </param><returns>
    ///               One or more tensors that were dequeued as a tuple.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation is not supported by all queues.  If a queue does not support
    ///               DequeueUpTo, then an Unimplemented error is returned.
    ///               
    ///               If the queue is closed and there are more than 0 but less than <c>n</c>
    ///               elements remaining, then instead of returning an OutOfRange error like
    ///               QueueDequeueMany, less than <c>n</c> elements are returned immediately.  If
    ///               the queue is closed and there are 0 elements left in the queue, then
    ///               an OutOfRange error is returned just like in QueueDequeueMany.
    ///               Otherwise the behavior is identical to QueueDequeueMany:
    ///               
    ///               This operation concatenates queue-element component tensors along the
    ///               0th dimension to make a single component tensor.  All of the components
    ///               in the dequeued tuple will have size <c>n</c> in the 0th dimension.
    ///               
    ///               This operation has k outputs, where <c>k</c> is the number of components in
    ///               the tuples stored in the given queue, and output <c>i</c> is the ith
    ///               component of the dequeued tuple.
    ///             </remarks>
    member this.QueueDequeueUpTo(handle : TF, n : TF, component_types : TFDataType[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueDequeueUpTo(handle.TFOutput, n.TFOutput, component_types, timeout_ms, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Dequeues <c>n</c> tuples of one or more tensors from the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="n">
    ///               The number of tuples to dequeue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueDequeueUpToV2'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue has fewer than n elements, this operation
    ///               will block for up to timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><param name="component_types">
    ///               The type of each component in a tuple.
    ///             </param><returns>
    ///               One or more tensors that were dequeued as a tuple.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation is not supported by all queues.  If a queue does not support
    ///               DequeueUpTo, then an Unimplemented error is returned.
    ///               
    ///               If the queue is closed and there are more than 0 but less than <c>n</c>
    ///               elements remaining, then instead of returning an OutOfRange error like
    ///               QueueDequeueMany, less than <c>n</c> elements are returned immediately.  If
    ///               the queue is closed and there are 0 elements left in the queue, then
    ///               an OutOfRange error is returned just like in QueueDequeueMany.
    ///               Otherwise the behavior is identical to QueueDequeueMany:
    ///               
    ///               This operation concatenates queue-element component tensors along the
    ///               0th dimension to make a single component tensor.  All of the components
    ///               in the dequeued tuple will have size n in the 0th dimension.
    ///               
    ///               This operation has <c>k</c> outputs, where <c>k</c> is the number of components in
    ///               the tuples stored in the given queue, and output <c>i</c> is the ith
    ///               component of the dequeued tuple.
    ///             </remarks>
    member this.QueueDequeueUpToV2(handle : TF, n : TF, component_types : TFDataType[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueDequeueUpToV2(handle.TFOutput, n.TFOutput, component_types, timeout_ms, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Dequeues a tuple of one or more tensors from the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueDequeueV2'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue is empty, this operation will block for up to
    ///               timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><param name="component_types">
    ///               The type of each component in a tuple.
    ///             </param><returns>
    ///               One or more tensors that were dequeued as a tuple.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation has k outputs, where k is the number of components
    ///               in the tuples stored in the given queue, and output i is the ith
    ///               component of the dequeued tuple.
    ///               
    ///               N.B. If the queue is empty, this operation will block until an element
    ///               has been dequeued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueDequeueV2(handle : TF, component_types : TFDataType[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueDequeueV2(handle.TFOutput, component_types, timeout_ms, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Enqueues a tuple of one or more tensors in the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="components">
    ///               One or more tensors from which the enqueued tensors should be taken.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueEnqueue'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue is full, this operation will block for up to
    ///               timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The components input has k elements, which correspond to the components of
    ///               tuples stored in the given queue.
    ///               
    ///               N.B. If the queue is full, this operation will block until the given
    ///               element has been enqueued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueEnqueue(handle : TF, components : TF[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueEnqueue(handle.TFOutput, components |> Array.map (fun x -> x.TFOutput), timeout_ms, operName)
    /// <summary>
    ///               Enqueues zero or more tuples of one or more tensors in the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="components">
    ///               One or more tensors from which the enqueued tensors should
    ///               be taken.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueEnqueueMany'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue is too full, this operation will block for up
    ///               to timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation slices each component tensor along the 0th dimension to
    ///               make multiple queue elements. All of the tuple components must have the
    ///               same size in the 0th dimension.
    ///               
    ///               The components input has k elements, which correspond to the components of
    ///               tuples stored in the given queue.
    ///               
    ///               N.B. If the queue is full, this operation will block until the given
    ///               elements have been enqueued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueEnqueueMany(handle : TF, components : TF[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueEnqueueMany(handle.TFOutput, components |> Array.map (fun x -> x.TFOutput), timeout_ms, operName)
    /// <summary>
    ///               Enqueues zero or more tuples of one or more tensors in the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="components">
    ///               One or more tensors from which the enqueued tensors should
    ///               be taken.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueEnqueueManyV2'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue is too full, this operation will block for up
    ///               to timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation slices each component tensor along the 0th dimension to
    ///               make multiple queue elements. All of the tuple components must have the
    ///               same size in the 0th dimension.
    ///               
    ///               The components input has k elements, which correspond to the components of
    ///               tuples stored in the given queue.
    ///               
    ///               N.B. If the queue is full, this operation will block until the given
    ///               elements have been enqueued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueEnqueueManyV2(handle : TF, components : TF[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueEnqueueManyV2(handle.TFOutput, components |> Array.map (fun x -> x.TFOutput), timeout_ms, operName)
    /// <summary>
    ///               Enqueues a tuple of one or more tensors in the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="components">
    ///               One or more tensors from which the enqueued tensors should be taken.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueEnqueueV2'.
    ///             </param><param name="timeout_ms">
    ///               Optional argument
    ///               If the queue is full, this operation will block for up to
    ///               timeout_ms milliseconds.
    ///               Note: This option is not supported yet.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The components input has k elements, which correspond to the components of
    ///               tuples stored in the given queue.
    ///               
    ///               N.B. If the queue is full, this operation will block until the given
    ///               element has been enqueued (or 'timeout_ms' elapses, if specified).
    ///             </remarks>
    member this.QueueEnqueueV2(handle : TF, components : TF[], ?timeout_ms : Int64, ?operName : String) =
        let timeout_ms = defaultArg (timeout_ms |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.QueueEnqueueV2(handle.TFOutput, components |> Array.map (fun x -> x.TFOutput), timeout_ms, operName)
    /// <summary>
    ///               Returns true if queue is closed.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueIsClosed'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns true if the queue is closed and false if the queue
    ///               is open.
    ///             </remarks>
    member this.QueueIsClosed(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.QueueIsClosed(handle.TFOutput, operName))
    /// <summary>
    ///               Returns true if queue is closed.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueIsClosedV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns true if the queue is closed and false if the queue
    ///               is open.
    ///             </remarks>
    member this.QueueIsClosedV2(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.QueueIsClosedV2(handle.TFOutput, operName))
    /// <summary>
    ///               Computes the number of elements in the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueSize'.
    ///             </param><returns>
    ///               The number of elements in the given queue.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.QueueSize(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.QueueSize(handle.TFOutput, operName))
    /// <summary>
    ///               Computes the number of elements in the given queue.
    ///             </summary><param name="handle">
    ///               The handle to a queue.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'QueueSizeV2'.
    ///             </param><returns>
    ///               The number of elements in the given queue.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.QueueSizeV2(handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.QueueSizeV2(handle.TFOutput, operName))
    /// <summary>
    ///               Randomly crop <c>image</c>.
    ///             </summary><param name="image">
    ///               3-D of shape <c>[height, width, channels]</c>.
    ///             </param><param name="size">
    ///               1-D of length 2 containing: <c>crop_height</c>, <c>crop_width</c>..
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomCrop'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either seed or seed2 are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               An second seed to avoid seed collision.
    ///             </param><returns>
    ///               3-D of shape <c>[crop_height, crop_width, channels].</c>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks><c>size</c> is a 1-D int64 tensor with 2 elements representing the crop height and
    ///               width.  The values must be non negative.
    ///               
    ///               This Op picks a random location in <c>image</c> and crops a <c>height</c> by <c>width</c>
    ///               rectangle from that location.  The random location is picked so the cropped
    ///               area will fit inside the original image.
    ///             </remarks>
    member this.RandomCrop(image : TF, size : TF, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomCrop(image.TFOutput, size.TFOutput, seed, seed2, operName))
    /// <summary>
    ///               Outputs random values from the Gamma distribution(s) described by alpha.
    ///             </summary><param name="shape">
    ///               1-D integer tensor. Shape of independent samples to draw from each
    ///               distribution described by the shape parameters given in alpha.
    ///             </param><param name="alpha">
    ///               A tensor in which each scalar is a "shape" parameter describing the
    ///               associated gamma distribution.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomGamma'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><returns>
    ///               A tensor with shape <c>shape + shape(alpha)</c>. Each slice
    ///               <c>[:, ..., :, i0, i1, ...iN]</c> contains the samples drawn for
    ///               <c>alpha[i0, i1, ...iN]</c>. The dtype of the output matches the dtype of alpha.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op uses the algorithm by Marsaglia et al. to acquire samples via
    ///               transformation-rejection from pairs of uniform and normal random variables.
    ///               See http://dl.acm.org/citation.cfm?id=358414
    ///             </remarks>
    member this.RandomGamma(shape : TF, alpha : TF, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomGamma(shape.TFOutput, alpha.TFOutput, seed, seed2, operName))
    /// <summary>
    ///               Computes the derivative of a Gamma random sample w.r.t. <c>alpha</c>.
    ///             </summary><param name="alpha"></param><param name="sample"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomGammaGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RandomGammaGrad(alpha : TF, sample : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomGammaGrad(alpha.TFOutput, sample.TFOutput, operName))
    /// <summary>
    ///               Use RandomPoissonV2 instead.
    ///             </summary><param name="shape"></param><param name="rate"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomPoisson'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///             </param><param name="seed2">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RandomPoisson(shape : TF, rate : TF, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomPoisson(shape.TFOutput, rate.TFOutput, seed, seed2, operName))
    /// <summary>
    ///               Outputs random values from the Poisson distribution(s) described by rate.
    ///             </summary><param name="shape">
    ///               1-D integer tensor. Shape of independent samples to draw from each
    ///               distribution described by the shape parameters given in rate.
    ///             </param><param name="rate">
    ///               A tensor in which each scalar is a "rate" parameter describing the
    ///               associated poisson distribution.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomPoissonV2'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="dtype">
    ///               Optional argument
    ///             </param><returns>
    ///               A tensor with shape <c>shape + shape(rate)</c>. Each slice
    ///               <c>[:, ..., :, i0, i1, ...iN]</c> contains the samples drawn for
    ///               <c>rate[i0, i1, ...iN]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This op uses two algorithms, depending on rate. If rate &amp;gt;= 10, then
    ///               the algorithm by Hormann is used to acquire samples via
    ///               transformation-rejection.
    ///               See http://www.sciencedirect.com/science/article/pii/0167668793909974.
    ///               
    ///               Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
    ///               random variables.
    ///               See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
    ///               Programming, Volume 2. Addison Wesley
    ///             </remarks>
    member this.RandomPoissonV2(shape : TF, rate : TF, ?seed : Int64, ?seed2 : Int64, ?dtype : TFDataType, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let dtype = defaultArg (dtype |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomPoissonV2(shape.TFOutput, rate.TFOutput, seed, seed2, dtype, operName))
    /// <summary>
    ///               Randomly shuffles a tensor along its first dimension.
    ///             </summary><param name="value">
    ///               The tensor to be shuffled.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomShuffle'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><returns>
    ///               A tensor of same shape and type as <c>value</c>, shuffled along its first
    ///               dimension.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The tensor is shuffled along dimension 0, such that each <c>value[j]</c> is mapped
    ///               to one and only one <c>output[i]</c>. For example, a mapping that might occur for a
    ///               3x2 tensor is:
    ///               
    ///                <code>
    ///               [[1, 2],       [[5, 6],
    ///               [3, 4],  ==&amp;gt;   [1, 2],
    ///               [5, 6]]        [3, 4]]
    ///                </code></remarks>
    member this.RandomShuffle(value : TF, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomShuffle(value.TFOutput, seed, seed2, operName))
    /// <summary>
    ///               A queue that randomizes the order of elements.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomShuffleQueue'.
    ///             </param><param name="shapes">
    ///               Optional argument
    ///               The shape of each component in a value. The length of this attr must
    ///               be either 0 or the same as the length of component_types. If the length of
    ///               this attr is 0, the shapes of queue elements are not constrained, and
    ///               only one element may be dequeued at a time.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///               The upper bound on the number of elements in this queue.
    ///               Negative numbers mean no limit.
    ///             </param><param name="min_after_dequeue">
    ///               Optional argument
    ///               Dequeue will block unless there would be this
    ///               many elements after the dequeue or the queue is closed. This
    ///               ensures a minimum level of mixing of elements.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either seed or seed2 is set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, a random seed is used.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this queue is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this queue will be shared under the given name
    ///               across multiple sessions.
    ///             </param><param name="component_types">
    ///               The type of each component in a value.
    ///             </param><returns>
    ///               The handle to the queue.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RandomShuffleQueue(component_types : TFDataType[], ?shapes : TFShape[], ?capacity : Int64, ?min_after_dequeue : Int64, ?seed : Int64, ?seed2 : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let shapes = defaultArg shapes null
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let min_after_dequeue = defaultArg (min_after_dequeue |> Option.map Nullable) (Nullable())
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomShuffleQueue(component_types, shapes, capacity, min_after_dequeue, seed, seed2, container, shared_name, operName))
    /// <summary>
    ///               A queue that randomizes the order of elements.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomShuffleQueueV2'.
    ///             </param><param name="shapes">
    ///               Optional argument
    ///               The shape of each component in a value. The length of this attr must
    ///               be either 0 or the same as the length of component_types. If the length of
    ///               this attr is 0, the shapes of queue elements are not constrained, and
    ///               only one element may be dequeued at a time.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///               The upper bound on the number of elements in this queue.
    ///               Negative numbers mean no limit.
    ///             </param><param name="min_after_dequeue">
    ///               Optional argument
    ///               Dequeue will block unless there would be this
    ///               many elements after the dequeue or the queue is closed. This
    ///               ensures a minimum level of mixing of elements.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either seed or seed2 is set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, a random seed is used.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this queue is placed in the given container.
    ///               Otherwise, a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               If non-empty, this queue will be shared under the given name
    ///               across multiple sessions.
    ///             </param><param name="component_types">
    ///               The type of each component in a value.
    ///             </param><returns>
    ///               The handle to the queue.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RandomShuffleQueueV2(component_types : TFDataType[], ?shapes : TFShape[], ?capacity : Int64, ?min_after_dequeue : Int64, ?seed : Int64, ?seed2 : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let shapes = defaultArg shapes null
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let min_after_dequeue = defaultArg (min_after_dequeue |> Option.map Nullable) (Nullable())
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomShuffleQueueV2(component_types, shapes, capacity, min_after_dequeue, seed, seed2, container, shared_name, operName))
    /// <summary>
    ///               Outputs random values from a normal distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomStandardNormal'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="dtype">
    ///               The type of the output.
    ///             </param><returns>
    ///               A tensor of the specified shape filled with random normal values.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values will have mean 0 and standard deviation 1.
    ///             </remarks>
    member this.RandomStandardNormal(shape : TF, dtype : TFDataType, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomStandardNormal(shape.TFOutput, dtype, seed, seed2, operName))
    /// <summary>
    ///               Outputs random values from a uniform distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomUniform'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><param name="dtype">
    ///               The type of the output.
    ///             </param><returns>
    ///               A tensor of the specified shape filled with uniform random values.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values follow a uniform distribution in the range <c>[0, 1)</c>. The
    ///               lower bound 0 is included in the range, while the upper bound 1 is excluded.
    ///             </remarks>
    member this.RandomUniform(shape : TF, dtype : TFDataType, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomUniform(shape.TFOutput, dtype, seed, seed2, operName))
    /// <summary>
    ///               Outputs random integers from a uniform distribution.
    ///             </summary><param name="shape">
    ///               The shape of the output tensor.
    ///             </param><param name="minval">
    ///               0-D.  Inclusive lower bound on the generated integers.
    ///             </param><param name="maxval">
    ///               0-D.  Exclusive upper bound on the generated integers.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RandomUniformInt'.
    ///             </param><param name="seed">
    ///               Optional argument
    ///               If either <c>seed</c> or <c>seed2</c> are set to be non-zero, the random number
    ///               generator is seeded by the given seed.  Otherwise, it is seeded by a
    ///               random seed.
    ///             </param><param name="seed2">
    ///               Optional argument
    ///               A second seed to avoid seed collision.
    ///             </param><returns>
    ///               A tensor of the specified shape filled with uniform random integers.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The generated values are uniform integers in the range <c>[minval, maxval)</c>.
    ///               The lower bound <c>minval</c> is included in the range, while the upper bound
    ///               <c>maxval</c> is excluded.
    ///               
    ///               The random integers are slightly biased unless <c>maxval - minval</c> is an exact
    ///               power of two.  The bias is small for values of <c>maxval - minval</c> significantly
    ///               smaller than the range of the output (either <c>2^32</c> or <c>2^64</c>).
    ///             </remarks>
    member this.RandomUniformInt(shape : TF, minval : TF, maxval : TF, ?seed : Int64, ?seed2 : Int64, ?operName : String) =
        let seed = defaultArg (seed |> Option.map Nullable) (Nullable())
        let seed2 = defaultArg (seed2 |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RandomUniformInt(shape.TFOutput, minval.TFOutput, maxval.TFOutput, seed, seed2, operName))
    /// <summary>
    ///               Creates a sequence of numbers.
    ///             </summary><param name="start">
    ///               0-D (scalar). First entry in the sequence.
    ///             </param><param name="limit">
    ///               0-D (scalar). Upper limit of sequence, exclusive.
    ///             </param><param name="delta">
    ///               0-D (scalar). Optional. Default is 1. Number that increments <c>start</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Range'.
    ///             </param><returns>
    ///               1-D.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation creates a sequence of numbers that begins at <c>start</c> and
    ///               extends by increments of <c>delta</c> up to but not including <c>limit</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 'start' is 3
    ///               # 'limit' is 18
    ///               # 'delta' is 3
    ///               tf.range(start, limit, delta) ==&amp;gt; [3, 6, 9, 12, 15]
    ///                </code></remarks>
    member this.Range(start : TF, limit : TF, delta : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Range(start.TFOutput, limit.TFOutput, delta.TFOutput, operName))
    /// <summary>
    ///               Creates a dataset with a range of values. Corresponds to python's xrange.
    ///             </summary><param name="start">
    ///               corresponds to start in python's xrange().
    ///             </param><param name="stop">
    ///               corresponds to stop in python's xrange().
    ///             </param><param name="step">
    ///               corresponds to step in python's xrange().
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RangeDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RangeDataset(start : TF, stop : TF, step : TF, output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RangeDataset(start.TFOutput, stop.TFOutput, step.TFOutput, output_types, output_shapes, operName))
    /// <summary>
    ///               Returns the rank of a tensor.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Rank'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operation returns an integer representing the rank of <c>input</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
    ///               # shape of tensor 't' is [2, 2, 3]
    ///               rank(t) ==&amp;gt; 3
    ///                </code>
    ///               
    ///               **Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
    ///               of a tensor is the number of indices required to uniquely select each element
    ///               of the tensor. Rank is also known as "order", "degree", or "ndims."
    ///             </remarks>
    member this.Rank(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Rank(input.TFOutput, operName))
    /// <summary>
    ///               Returns the number of records this Reader has produced.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderNumRecordsProduced'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This is the same as the number of ReaderRead executions that have
    ///               succeeded.
    ///             </remarks>
    member this.ReaderNumRecordsProduced(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReaderNumRecordsProduced(reader_handle.TFOutput, operName))
    /// <summary>
    ///               Returns the number of records this Reader has produced.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderNumRecordsProducedV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This is the same as the number of ReaderRead executions that have
    ///               succeeded.
    ///             </remarks>
    member this.ReaderNumRecordsProducedV2(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReaderNumRecordsProducedV2(reader_handle.TFOutput, operName))
    /// <summary>
    ///               Returns the number of work units this Reader has finished processing.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderNumWorkUnitsCompleted'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ReaderNumWorkUnitsCompleted(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReaderNumWorkUnitsCompleted(reader_handle.TFOutput, operName))
    /// <summary>
    ///               Returns the number of work units this Reader has finished processing.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderNumWorkUnitsCompletedV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ReaderNumWorkUnitsCompletedV2(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReaderNumWorkUnitsCompletedV2(reader_handle.TFOutput, operName))
    /// <summary>
    ///               Returns the next record (key, value pair) produced by a Reader.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="queue_handle">
    ///               Handle to a Queue, with string work items.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderRead'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               key: A scalar.
    ///               value: A scalar.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Will dequeue from the input queue if necessary (e.g. when the
    ///               Reader needs to start reading from a new file since it has finished
    ///               with the previous file).
    ///             </remarks>
    member this.ReaderRead(reader_handle : TF, queue_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderRead(reader_handle.TFOutput, queue_handle.TFOutput, operName)
    /// <summary>
    ///               Returns up to <c>num_records</c> (key, value) pairs produced by a Reader.
    ///             </summary><param name="reader_handle">
    ///               Handle to a <c>Reader</c>.
    ///             </param><param name="queue_handle">
    ///               Handle to a <c>Queue</c>, with string work items.
    ///             </param><param name="num_records">
    ///               number of records to read from <c>Reader</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderReadUpTo'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               keys: A 1-D tensor.
    ///               values: A 1-D tensor.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Will dequeue from the input queue if necessary (e.g. when the
    ///               Reader needs to start reading from a new file since it has finished
    ///               with the previous file).
    ///               It may return less than <c>num_records</c> even before the last batch.
    ///             </remarks>
    member this.ReaderReadUpTo(reader_handle : TF, queue_handle : TF, num_records : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderReadUpTo(reader_handle.TFOutput, queue_handle.TFOutput, num_records.TFOutput, operName)
    /// <summary>
    ///               Returns up to <c>num_records</c> (key, value) pairs produced by a Reader.
    ///             </summary><param name="reader_handle">
    ///               Handle to a <c>Reader</c>.
    ///             </param><param name="queue_handle">
    ///               Handle to a <c>Queue</c>, with string work items.
    ///             </param><param name="num_records">
    ///               number of records to read from <c>Reader</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderReadUpToV2'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               keys: A 1-D tensor.
    ///               values: A 1-D tensor.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Will dequeue from the input queue if necessary (e.g. when the
    ///               Reader needs to start reading from a new file since it has finished
    ///               with the previous file).
    ///               It may return less than <c>num_records</c> even before the last batch.
    ///             </remarks>
    member this.ReaderReadUpToV2(reader_handle : TF, queue_handle : TF, num_records : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderReadUpToV2(reader_handle.TFOutput, queue_handle.TFOutput, num_records.TFOutput, operName)
    /// <summary>
    ///               Returns the next record (key, value pair) produced by a Reader.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="queue_handle">
    ///               Handle to a Queue, with string work items.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderReadV2'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               key: A scalar.
    ///               value: A scalar.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               Will dequeue from the input queue if necessary (e.g. when the
    ///               Reader needs to start reading from a new file since it has finished
    ///               with the previous file).
    ///             </remarks>
    member this.ReaderReadV2(reader_handle : TF, queue_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderReadV2(reader_handle.TFOutput, queue_handle.TFOutput, operName)
    /// <summary>
    ///               Restore a Reader to its initial clean state.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderReset'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.ReaderReset(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderReset(reader_handle.TFOutput, operName)
    /// <summary>
    ///               Restore a Reader to its initial clean state.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderResetV2'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.ReaderResetV2(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderResetV2(reader_handle.TFOutput, operName)
    /// <summary>
    ///               Restore a reader to a previously saved state.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="state">
    ///               Result of a ReaderSerializeState of a Reader with type
    ///               matching reader_handle.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderRestoreState'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               Not all Readers support being restored, so this can produce an
    ///               Unimplemented error.
    ///             </remarks>
    member this.ReaderRestoreState(reader_handle : TF, state : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderRestoreState(reader_handle.TFOutput, state.TFOutput, operName)
    /// <summary>
    ///               Restore a reader to a previously saved state.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="state">
    ///               Result of a ReaderSerializeState of a Reader with type
    ///               matching reader_handle.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderRestoreStateV2'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               Not all Readers support being restored, so this can produce an
    ///               Unimplemented error.
    ///             </remarks>
    member this.ReaderRestoreStateV2(reader_handle : TF, state : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ReaderRestoreStateV2(reader_handle.TFOutput, state.TFOutput, operName)
    /// <summary>
    ///               Produce a string tensor that encodes the state of a Reader.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderSerializeState'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Not all Readers support being serialized, so this can produce an
    ///               Unimplemented error.
    ///             </remarks>
    member this.ReaderSerializeState(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReaderSerializeState(reader_handle.TFOutput, operName))
    /// <summary>
    ///               Produce a string tensor that encodes the state of a Reader.
    ///             </summary><param name="reader_handle">
    ///               Handle to a Reader.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReaderSerializeStateV2'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Not all Readers support being serialized, so this can produce an
    ///               Unimplemented error.
    ///             </remarks>
    member this.ReaderSerializeStateV2(reader_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReaderSerializeStateV2(reader_handle.TFOutput, operName))
    /// <summary>
    ///               Reads and outputs the entire contents of the input filename.
    ///             </summary><param name="filename"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReadFile'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ReadFile(filename : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReadFile(filename.TFOutput, operName))
    /// <summary>
    ///               Reads the value of a variable.
    ///             </summary><param name="resource">
    ///               handle to the resource in which to store the variable.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReadVariableOp'.
    ///             </param><param name="dtype">
    ///               the dtype of the value.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The tensor returned by this operation is immutable.
    ///               
    ///               The value returned by this operation is guaranteed to be influenced by all the
    ///               writes on which this operation depends directly or indirectly, and to not be
    ///               influenced by any of the writes which depend directly or indirectly on this
    ///               operation.
    ///             </remarks>
    member this.ReadVariableOp(resource : TF, dtype : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReadVariableOp(resource.TFOutput, dtype, operName))
    /// <summary>
    ///               Returns the real part of a complex number.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Real'.
    ///             </param><param name="Tout">
    ///               Optional argument
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Given a tensor <c>input</c> of complex numbers, this operation returns a tensor of
    ///               type <c>float</c> that is the real part of each element in <c>input</c>. All elements in
    ///               <c>input</c> must be complex numbers of the form \\(a + bj\\), where *a* is the real
    ///               part returned by this operation and *b* is the imaginary part.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
    ///               tf.real(input) ==&amp;gt; [-2.25, 3.25]
    ///                </code></remarks>
    member this.Real(input : TF, ?Tout : TFDataType, ?operName : String) =
        let Tout = defaultArg (Tout |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Real(input.TFOutput, Tout, operName))
    /// <summary>
    ///               Returns x / y element-wise for real types.
    ///             </summary><param name="x"></param><param name="y"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RealDiv'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               If <c>x</c> and <c>y</c> are reals, this will return the floating-point division.
    ///               
    ///               *NOTE*: <c>Div</c> supports broadcasting. More about broadcasting
    ///               [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
    ///             </remarks>
    member this.RealDiv(x : TF, y : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RealDiv(x.TFOutput, y.TFOutput, operName))
    /// <summary>
    ///               Computes the reciprocal of x element-wise.
    ///             </summary><param name="x"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Reciprocal'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               I.e., \\(y = 1 / x\\).
    ///             </remarks>
    member this.Reciprocal(x : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Reciprocal(x.TFOutput, operName))
    /// <summary>
    ///               Computes the gradient for the inverse of <c>x</c> wrt its input.
    ///             </summary><param name="y"></param><param name="dy"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReciprocalGrad'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Specifically, <c>grad = -dy * y*y</c>, where <c>y = 1/x</c>, and <c>dy</c>
    ///               is the corresponding input gradient.
    ///             </remarks>
    member this.ReciprocalGrad(y : TF, dy : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReciprocalGrad(y.TFOutput, dy.TFOutput, operName))
    /// <summary>
    ///               Emits randomized records.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RecordInput'.
    ///             </param><param name="file_random_seed">
    ///               Optional argument
    ///               Random seeds used to produce randomized records.
    ///             </param><param name="file_shuffle_shift_ratio">
    ///               Optional argument
    ///               Shifts the list of files after the list is randomly
    ///               shuffled.
    ///             </param><param name="file_buffer_size">
    ///               Optional argument
    ///               The randomization shuffling buffer.
    ///             </param><param name="file_parallelism">
    ///               Optional argument
    ///               How many sstables are opened and concurrently iterated over.
    ///             </param><param name="batch_size">
    ///               Optional argument
    ///               The batch size.
    ///             </param><param name="compression_type">
    ///               Optional argument
    ///               The type of compression for the file. Currently ZLIB and
    ///               GZIP are supported. Defaults to none.
    ///             </param><param name="file_pattern">
    ///               Glob pattern for the data files.
    ///             </param><returns>
    ///               A tensor of shape [batch_size].
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RecordInput(file_pattern : String, ?file_random_seed : Int64, ?file_shuffle_shift_ratio : Single, ?file_buffer_size : Int64, ?file_parallelism : Int64, ?batch_size : Int64, ?compression_type : String, ?operName : String) =
        let file_random_seed = defaultArg (file_random_seed |> Option.map Nullable) (Nullable())
        let file_shuffle_shift_ratio = defaultArg (file_shuffle_shift_ratio |> Option.map Nullable) (Nullable())
        let file_buffer_size = defaultArg (file_buffer_size |> Option.map Nullable) (Nullable())
        let file_parallelism = defaultArg (file_parallelism |> Option.map Nullable) (Nullable())
        let batch_size = defaultArg (batch_size |> Option.map Nullable) (Nullable())
        let compression_type = defaultArg compression_type null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RecordInput(file_pattern, file_random_seed, file_shuffle_shift_ratio, file_buffer_size, file_parallelism, batch_size, compression_type, operName))
    /// <summary>
    ///               An op that receives embedding activations on the TPU.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RecvTPUEmbeddingActivations'.
    ///             </param><param name="num_outputs">
    ///               The number of output activation tensors, equal to the number of
    ///               embedding tables in the model.
    ///             </param><param name="config">
    ///               Serialized TPUEmbeddingConfiguration proto.
    ///             </param><returns>
    ///               A TensorList of embedding activations containing one Tensor per
    ///               embedding table in the model.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The TPU system performs the embedding lookups and aggregations specified by
    ///               the arguments to TPUEmbeddingEnqueue(Integer/Sparse/SparseTensor)Batch. The
    ///               results of these aggregations are visible to the Tensorflow Graph as the
    ///               outputs of a RecvTPUEmbeddingActivations op. This op returns a list containing
    ///               one Tensor of activations per table specified in the model. There can be at
    ///               most one RecvTPUEmbeddingActivations op in the TPU graph.
    ///             </remarks>
    member this.RecvTPUEmbeddingActivations(num_outputs : Int64, config : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.RecvTPUEmbeddingActivations(num_outputs, config, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Joins a string Tensor across the given dimensions.
    ///             </summary><param name="inputs">
    ///               The input to be joined.  All reduced indices must have non-zero size.
    ///             </param><param name="reduction_indices">
    ///               The dimensions to reduce over.  Dimensions are reduced in the
    ///               order specified.  Omitting <c>reduction_indices</c> is equivalent to passing
    ///               <c>[n-1, n-2, ..., 0]</c>.  Negative indices from <c>-n</c> to <c>-1</c> are supported.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReduceJoin'.
    ///             </param><param name="keep_dims">
    ///               Optional argument
    ///               If <c>True</c>, retain reduced dimensions with length <c>1</c>.
    ///             </param><param name="separator">
    ///               Optional argument
    ///               The separator to use when joining.
    ///             </param><returns>
    ///               Has shape equal to that of the input with reduced dimensions removed or
    ///               set to <c>1</c> depending on <c>keep_dims</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Computes the string join across dimensions in the given string Tensor of shape
    ///               <c>[\\(d_0, d_1, ..., d_{n-1}\\)]</c>.  Returns a new Tensor created by joining the input
    ///               strings with the given separator (default: empty string).  Negative indices are
    ///               counted backwards from the end, with <c>-1</c> being equivalent to <c>n - 1</c>.  If
    ///               indices are not specified, joins across all dimensions beginning from <c>n - 1</c>
    ///               through <c>0</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor <c>a</c> is [["a", "b"], ["c", "d"]]
    ///               tf.reduce_join(a, 0) ==&amp;gt; ["ac", "bd"]
    ///               tf.reduce_join(a, 1) ==&amp;gt; ["ab", "cd"]
    ///               tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==&amp;gt; ["ac", "bd"]
    ///               tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==&amp;gt; ["ab", "cd"]
    ///               tf.reduce_join(a, 0, keep_dims=True) ==&amp;gt; [["ac", "bd"]]
    ///               tf.reduce_join(a, 1, keep_dims=True) ==&amp;gt; [["ab"], ["cd"]]
    ///               tf.reduce_join(a, 0, separator=".") ==&amp;gt; ["a.c", "b.d"]
    ///               tf.reduce_join(a, [0, 1]) ==&amp;gt; "acbd"
    ///               tf.reduce_join(a, [1, 0]) ==&amp;gt; "abcd"
    ///               tf.reduce_join(a, []) ==&amp;gt; [["a", "b"], ["c", "d"]]
    ///               tf.reduce_join(a) = tf.reduce_join(a, [1, 0]) ==&amp;gt; "abcd"
    ///                </code></remarks>
    member this.ReduceJoin(inputs : TF, reduction_indices : TF, ?keep_dims : Boolean, ?separator : String, ?operName : String) =
        let keep_dims = defaultArg (keep_dims |> Option.map Nullable) (Nullable())
        let separator = defaultArg separator null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReduceJoin(inputs.TFOutput, reduction_indices.TFOutput, keep_dims, separator, operName))
    /// <summary>
    ///               Creates or finds a child frame, and makes <c>data</c> available to the child frame.
    ///             </summary><param name="data">
    ///               The tensor to be made available to the child frame.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefEnter'.
    ///             </param><param name="is_constant">
    ///               Optional argument
    ///               If true, the output is constant within the child frame.
    ///             </param><param name="parallel_iterations">
    ///               Optional argument
    ///               The number of iterations allowed to run in parallel.
    ///             </param><param name="frame_name">
    ///               The name of the child frame.
    ///             </param><returns>
    ///               The same tensor as <c>data</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The unique <c>frame_name</c> is used by the <c>Executor</c> to identify frames. If
    ///               <c>is_constant</c> is true, <c>output</c> is a constant in the child frame; otherwise
    ///               it may be changed in the child frame. At most <c>parallel_iterations</c> iterations
    ///               are run in parallel in the child frame.
    ///             </remarks>
    member this.RefEnter(data : TF, frame_name : String, ?is_constant : Boolean, ?parallel_iterations : Int64, ?operName : String) =
        let is_constant = defaultArg (is_constant |> Option.map Nullable) (Nullable())
        let parallel_iterations = defaultArg (parallel_iterations |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RefEnter(data.TFOutput, frame_name, is_constant, parallel_iterations, operName))
    /// <summary>
    ///               Exits the current frame to its parent frame.
    ///             </summary><param name="data">
    ///               The tensor to be made available to the parent frame.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefExit'.
    ///             </param><returns>
    ///               The same tensor as <c>data</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Exit makes its input <c>data</c> available to the parent frame.
    ///             </remarks>
    member this.RefExit(data : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RefExit(data.TFOutput, operName))
    /// <summary>
    ///               Return the same ref tensor as the input ref tensor.
    ///             </summary><param name="input"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefIdentity'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RefIdentity(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RefIdentity(input.TFOutput, operName))
    /// <summary>
    ///               Forwards the value of an available tensor from <c>inputs</c> to <c>output</c>.
    ///             </summary><param name="inputs">
    ///               The input tensors, exactly one of which will become available.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefMerge'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output: Will be set to the available input tensor.
    ///               value_index: The index of the chosen input tensor in <c>inputs</c>.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks><c>Merge</c> waits for at least one of the tensors in <c>inputs</c> to become available.
    ///               It is usually combined with <c>Switch</c> to implement branching.
    ///               
    ///               <c>Merge</c> forwards the first tensor for become available to <c>output</c>, and sets
    ///               <c>value_index</c> to its index in <c>inputs</c>.
    ///             </remarks>
    member this.RefMerge(inputs : TF[], ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.RefMerge(inputs |> Array.map (fun x -> x.TFOutput), operName)
    /// <summary>
    ///               Makes its input available to the next iteration.
    ///             </summary><param name="data">
    ///               The tensor to be made available to the next iteration.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefNextIteration'.
    ///             </param><returns>
    ///               The same tensor as <c>data</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RefNextIteration(data : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RefNextIteration(data.TFOutput, operName))
    /// <summary>
    ///               Forwards the <c>index</c>th element of <c>inputs</c> to <c>output</c>.
    ///             </summary><param name="index">
    ///               A scalar that determines the input that gets selected.
    ///             </param><param name="inputs">
    ///               A list of ref tensors, one of which will be forwarded to <c>output</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefSelect'.
    ///             </param><returns>
    ///               The forwarded tensor.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RefSelect(index : TF, inputs : TF[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RefSelect(index.TFOutput, inputs |> Array.map (fun x -> x.TFOutput), operName))
    /// <summary>
    ///               Forwards the ref tensor <c>data</c> to the output port determined by <c>pred</c>.
    ///             </summary><param name="data">
    ///               The ref tensor to be forwarded to the appropriate output.
    ///             </param><param name="pred">
    ///               A scalar that specifies which output port will receive data.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RefSwitch'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_false: If <c>pred</c> is false, data will be forwarded to this output.
    ///               output_true: If <c>pred</c> is true, data will be forwarded to this output.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               If <c>pred</c> is true, the <c>data</c> input is forwarded to <c>output_true</c>. Otherwise,
    ///               the data goes to <c>output_false</c>.
    ///               
    ///               See also <c>Switch</c> and <c>Merge</c>.
    ///             </remarks>
    member this.RefSwitch(data : TF, pred : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.RefSwitch(data.TFOutput, pred.TFOutput, operName)
    /// <summary>
    ///               Check if the input matches the regex pattern.
    ///             </summary><param name="input">
    ///               A string tensor of the text to be processed.
    ///             </param><param name="pattern">
    ///               A scalar string tensor containing the regular expression to match the input.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RegexFullMatch'.
    ///             </param><returns>
    ///               A bool tensor with the same shape as <c>input</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The input is a string tensor of any shape. The pattern is a scalar
    ///               string tensor which is applied to every element of the input tensor.
    ///               The boolean values (True or False) of the output tensor indicate
    ///               if the input matches the regex pattern provided.
    ///               
    ///               The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
    ///             </remarks>
    member this.RegexFullMatch(input : TF, pattern : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RegexFullMatch(input.TFOutput, pattern.TFOutput, operName))
    /// <summary>
    ///               Replaces the match of pattern in input with rewrite.
    ///             </summary><param name="input">
    ///               The text to be processed.
    ///             </param><param name="pattern">
    ///               The regular expression to match the input.
    ///             </param><param name="rewrite">
    ///               The rewrite to be applied to the matched expresion.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RegexReplace'.
    ///             </param><param name="replace_global">
    ///               Optional argument
    ///               If True, the replacement is global, otherwise the replacement
    ///               is done only on the first match.
    ///             </param><returns>
    ///               The text after applying pattern and rewrite.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
    ///             </remarks>
    member this.RegexReplace(input : TF, pattern : TF, rewrite : TF, ?replace_global : Boolean, ?operName : String) =
        let replace_global = defaultArg (replace_global |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RegexReplace(input.TFOutput, pattern.TFOutput, rewrite.TFOutput, replace_global, operName))
    /// <summary>
    ///               Computes rectified linear: <c>max(features, 0)</c>.
    ///             </summary><param name="features"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Relu'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Relu(features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Relu(features.TFOutput, operName))
    /// <summary>
    ///               Computes rectified linear 6: <c>min(max(features, 0), 6)</c>.
    ///             </summary><param name="features"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Relu6'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Relu6(features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Relu6(features.TFOutput, operName))
    /// <summary>
    ///               Computes rectified linear 6 gradients for a Relu6 operation.
    ///             </summary><param name="gradients">
    ///               The backpropagated gradients to the corresponding Relu6 operation.
    ///             </param><param name="features">
    ///               The features passed as input to the corresponding Relu6 operation, or
    ///               its output; using either one produces the same result.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Relu6Grad'.
    ///             </param><returns>
    ///               The gradients:
    ///               <c>gradients * (features &amp;gt; 0) * (features &amp;lt; 6)</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.Relu6Grad(gradients : TF, features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Relu6Grad(gradients.TFOutput, features.TFOutput, operName))
    /// <summary>
    ///               Computes rectified linear gradients for a Relu operation.
    ///             </summary><param name="gradients">
    ///               The backpropagated gradients to the corresponding Relu operation.
    ///             </param><param name="features">
    ///               The features passed as input to the corresponding Relu operation, OR
    ///               the outputs of that operation (both work equivalently).
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ReluGrad'.
    ///             </param><returns><c>gradients * (features &amp;gt; 0)</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ReluGrad(gradients : TF, features : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ReluGrad(gradients.TFOutput, features.TFOutput, operName))
    /// <summary>
    ///               Execute a sub graph on a remote processor.
    ///             </summary><param name="inputs">
    ///               Arbitrary number of tensors with arbitrary data types
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RemoteFusedGraphExecute'.
    ///             </param><param name="Toutputs"></param><param name="serialized_remote_fused_graph_execute_info">
    ///               Serialized protocol buffer
    ///               of RemoteFusedGraphExecuteInfo which contains graph specifications.
    ///             </param><returns>
    ///               Arbitrary number of tensors with arbitrary data types
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The graph specifications(such as graph itself, input tensors and output names)
    ///               are stored as a serialized protocol buffer of RemoteFusedGraphExecuteInfo
    ///               as serialized_remote_fused_graph_execute_info.
    ///               The specifications will be passed to a dedicated registered
    ///               remote fused graph executor.  The executor will send the graph specifications
    ///               to a remote processor and execute that graph.  The execution results
    ///               will be passed to consumer nodes as outputs of this node.
    ///             </remarks>
    member this.RemoteFusedGraphExecute(inputs : TF[], Toutputs : TFDataType[], serialized_remote_fused_graph_execute_info : String, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.RemoteFusedGraphExecute(inputs |> Array.map (fun x -> x.TFOutput), Toutputs, serialized_remote_fused_graph_execute_info, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Creates a dataset that emits the outputs of <c>input_dataset</c><c>count</c> times.
    ///             </summary><param name="input_dataset"></param><param name="count">
    ///               A scalar representing the number of times that <c>input_dataset</c> should
    ///               be repeated. A value of <c>-1</c> indicates that it should be repeated infinitely.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RepeatDataset'.
    ///             </param><param name="output_types"></param><param name="output_shapes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.RepeatDataset(input_dataset : TF, count : TF, output_types : TFDataType[], output_shapes : TFShape[], ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.RepeatDataset(input_dataset.TFOutput, count.TFOutput, output_types, output_shapes, operName))
    /// <summary>
    ///               Given a quantized tensor described by (input, input_min, input_max), outputs a
    ///             </summary><param name="input"></param><param name="input_min">
    ///               The float value that the minimum quantized input value represents.
    ///             </param><param name="input_max">
    ///               The float value that the maximum quantized input value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'RequantizationRange'.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output_min: The computed min output.
    ///               output_max: the computed max output.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               range that covers the actual values present in that tensor.  This op is
    ///               typically used to produce the requested_output_min and requested_output_max for
    ///               Requantize.
    ///             </remarks>
    member this.RequantizationRange(input : TF, input_min : TF, input_max : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.RequantizationRange(input.TFOutput, input_min.TFOutput, input_max.TFOutput, operName)
    /// <summary>
    ///               Convert the quantized 'input' tensor into a lower-precision 'output', using the
    ///             </summary><param name="input"></param><param name="input_min">
    ///               The float value that the minimum quantized input value represents.
    ///             </param><param name="input_max">
    ///               The float value that the maximum quantized input value represents.
    ///             </param><param name="requested_output_min">
    ///               The float value that the minimum quantized output value represents.
    ///             </param><param name="requested_output_max">
    ///               The float value that the maximum quantized output value represents.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Requantize'.
    ///             </param><param name="out_type">
    ///               The type of the output. Should be a lower bit depth than Tinput.
    ///             </param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               output:
    ///               output_min: The requested_output_min value is copied into this output.
    ///               output_max: The requested_output_max value is copied into this output.
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               output range specified with 'requested_output_min' and 'requested_output_max'.
    ///               
    ///               [input_min, input_max] are scalar floats that specify the range for the float
    ///               interpretation of the 'input' data. For example, if input_min is -1.0f and
    ///               input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
    ///               value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
    ///             </remarks>
    member this.Requantize(input : TF, input_min : TF, input_max : TF, requested_output_min : TF, requested_output_max : TF, out_type : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.Requantize(input.TFOutput, input_min.TFOutput, input_max.TFOutput, requested_output_min.TFOutput, requested_output_max.TFOutput, out_type, operName)
    /// <summary>
    ///               Reshapes a tensor.
    ///             </summary><param name="tensor"></param><param name="shape">
    ///               Defines the shape of the output tensor.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'Reshape'.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Given <c>tensor</c>, this operation returns a tensor that has the same values
    ///               as <c>tensor</c> with shape <c>shape</c>.
    ///               
    ///               If one component of <c>shape</c> is the special value -1, the size of that dimension
    ///               is computed so that the total size remains constant.  In particular, a <c>shape</c>
    ///               of <c>[-1]</c> flattens into 1-D.  At most one component of <c>shape</c> can be -1.
    ///               
    ///               If <c>shape</c> is 1-D or higher, then the operation returns a tensor with shape
    ///               <c>shape</c> filled with the values of <c>tensor</c>. In this case, the number of elements
    ///               implied by <c>shape</c> must be the same as the number of elements in <c>tensor</c>.
    ///               
    ///               For example:
    ///               
    ///                <code>
    ///               # tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
    ///               # tensor 't' has shape [9]
    ///               reshape(t, [3, 3]) ==&amp;gt; [[1, 2, 3],
    ///               [4, 5, 6],
    ///               [7, 8, 9]]
    ///               
    ///               # tensor 't' is [[[1, 1], [2, 2]],
    ///               #                [[3, 3], [4, 4]]]
    ///               # tensor 't' has shape [2, 2, 2]
    ///               reshape(t, [2, 4]) ==&amp;gt; [[1, 1, 2, 2],
    ///               [3, 3, 4, 4]]
    ///               
    ///               # tensor 't' is [[[1, 1, 1],
    ///               #                 [2, 2, 2]],
    ///               #                [[3, 3, 3],
    ///               #                 [4, 4, 4]],
    ///               #                [[5, 5, 5],
    ///               #                 [6, 6, 6]]]
    ///               # tensor 't' has shape [3, 2, 3]
    ///               # pass '[-1]' to flatten 't'
    ///               reshape(t, [-1]) ==&amp;gt; [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
    ///               
    ///               # -1 can also be used to infer the shape
    ///               
    ///               # -1 is inferred to be 9:
    ///               reshape(t, [2, -1]) ==&amp;gt; [[1, 1, 1, 2, 2, 2, 3, 3, 3],
    ///               [4, 4, 4, 5, 5, 5, 6, 6, 6]]
    ///               # -1 is inferred to be 2:
    ///               reshape(t, [-1, 9]) ==&amp;gt; [[1, 1, 1, 2, 2, 2, 3, 3, 3],
    ///               [4, 4, 4, 5, 5, 5, 6, 6, 6]]
    ///               # -1 is inferred to be 3:
    ///               reshape(t, [ 2, -1, 3]) ==&amp;gt; [[[1, 1, 1],
    ///               [2, 2, 2],
    ///               [3, 3, 3]],
    ///               [[4, 4, 4],
    ///               [5, 5, 5],
    ///               [6, 6, 6]]]
    ///               
    ///               # tensor 't' is [7]
    ///               # shape <c>[]</c> reshapes to a scalar
    ///               reshape(t, []) ==&amp;gt; 7
    ///                </code></remarks>
    member this.Reshape(tensor : TF, shape : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.Reshape(tensor.TFOutput, shape.TFOutput, operName))
    /// <summary>
    ///               Resize <c>images</c> to <c>size</c> using area interpolation.
    ///             </summary><param name="images">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="size">
    ///               = A 1-D int32 Tensor of 2 elements: <c>new_height, new_width</c>.  The
    ///               new size for the images.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeArea'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and output tensors are
    ///               aligned, preserving the values at the corner pixels. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape
    ///               <c>[batch, new_height, new_width, channels]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Input images can be of different types but output images are always float.
    ///               
    ///               The range of pixel values for the output image might be slightly different
    ///               from the range for the input image because of limited numerical precision.
    ///               To guarantee an output range, for example <c>[0.0, 1.0]</c>, apply
    ///               <c>tf.clip_by_value</c> to the output.
    ///               
    ///               Each output pixel is computed by first transforming the pixel's footprint into
    ///               the input tensor and then averaging the pixels that intersect the footprint. An
    ///               input pixel's contribution to the average is weighted by the fraction of its
    ///               area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
    ///             </remarks>
    member this.ResizeArea(images : TF, size : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeArea(images.TFOutput, size.TFOutput, align_corners, operName))
    /// <summary>
    ///               Resize <c>images</c> to <c>size</c> using bicubic interpolation.
    ///             </summary><param name="images">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="size">
    ///               = A 1-D int32 Tensor of 2 elements: <c>new_height, new_width</c>.  The
    ///               new size for the images.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeBicubic'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and output tensors are
    ///               aligned, preserving the values at the corner pixels. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape
    ///               <c>[batch, new_height, new_width, channels]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Input images can be of different types but output images are always float.
    ///             </remarks>
    member this.ResizeBicubic(images : TF, size : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeBicubic(images.TFOutput, size.TFOutput, align_corners, operName))
    /// <summary>
    ///               Computes the gradient of bicubic interpolation.
    ///             </summary><param name="grads">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="original_image">
    ///               4-D with shape <c>[batch, orig_height, orig_width, channels]</c>,
    ///               The image tensor that was resized.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeBicubicGrad'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and grad tensors are
    ///               aligned. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape <c>[batch, orig_height, orig_width, channels]</c>.
    ///               Gradients with respect to the input image. Input image must have been
    ///               float or double.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ResizeBicubicGrad(grads : TF, original_image : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeBicubicGrad(grads.TFOutput, original_image.TFOutput, align_corners, operName))
    /// <summary>
    ///               Resize <c>images</c> to <c>size</c> using bilinear interpolation.
    ///             </summary><param name="images">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="size">
    ///               = A 1-D int32 Tensor of 2 elements: <c>new_height, new_width</c>.  The
    ///               new size for the images.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeBilinear'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and output tensors are
    ///               aligned, preserving the values at the corner pixels. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape
    ///               <c>[batch, new_height, new_width, channels]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Input images can be of different types but output images are always float.
    ///             </remarks>
    member this.ResizeBilinear(images : TF, size : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeBilinear(images.TFOutput, size.TFOutput, align_corners, operName))
    /// <summary>
    ///               Computes the gradient of bilinear interpolation.
    ///             </summary><param name="grads">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="original_image">
    ///               4-D with shape <c>[batch, orig_height, orig_width, channels]</c>,
    ///               The image tensor that was resized.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeBilinearGrad'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and grad tensors are
    ///               aligned. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape <c>[batch, orig_height, orig_width, channels]</c>.
    ///               Gradients with respect to the input image. Input image must have been
    ///               float or double.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ResizeBilinearGrad(grads : TF, original_image : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeBilinearGrad(grads.TFOutput, original_image.TFOutput, align_corners, operName))
    /// <summary>
    ///               Resize <c>images</c> to <c>size</c> using nearest neighbor interpolation.
    ///             </summary><param name="images">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="size">
    ///               = A 1-D int32 Tensor of 2 elements: <c>new_height, new_width</c>.  The
    ///               new size for the images.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeNearestNeighbor'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and output tensors are
    ///               aligned, preserving the values at the corner pixels. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape
    ///               <c>[batch, new_height, new_width, channels]</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ResizeNearestNeighbor(images : TF, size : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeNearestNeighbor(images.TFOutput, size.TFOutput, align_corners, operName))
    /// <summary>
    ///               Computes the gradient of nearest neighbor interpolation.
    ///             </summary><param name="grads">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="size">
    ///               = A 1-D int32 Tensor of 2 elements: <c>orig_height, orig_width</c>. The
    ///               original input size.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResizeNearestNeighborGrad'.
    ///             </param><param name="align_corners">
    ///               Optional argument
    ///               If true, the centers of the 4 corner pixels of the input and grad tensors are
    ///               aligned. Defaults to false.
    ///             </param><returns>
    ///               4-D with shape <c>[batch, orig_height, orig_width, channels]</c>. Gradients
    ///               with respect to the input image.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ResizeNearestNeighborGrad(grads : TF, size : TF, ?align_corners : Boolean, ?operName : String) =
        let align_corners = defaultArg (align_corners |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResizeNearestNeighborGrad(grads.TFOutput, size.TFOutput, align_corners, operName))
    /// <summary>
    ///               Update '*var' according to the adadelta scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="accum_update">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay factor. Must be a scalar.
    ///             </param><param name="epsilon">
    ///               Constant factor. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyAdadelta'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var, accum and update_accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               accum = rho() * accum + (1 - rho()) * grad.square();
    ///               update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
    ///               update_accum = rho() * update_accum + (1 - rho()) * update.square();
    ///               var -= update;
    ///             </remarks>
    member this.ResourceApplyAdadelta(var : TF, accum : TF, accum_update : TF, lr : TF, rho : TF, epsilon : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyAdadelta(var.TFOutput, accum.TFOutput, accum_update.TFOutput, lr.TFOutput, rho.TFOutput, epsilon.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the adagrad scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyAdagrad'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="update_slots">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               accum += grad * grad
    ///               var -= lr * grad * (1 / sqrt(accum))
    ///             </remarks>
    member this.ResourceApplyAdagrad(var : TF, accum : TF, lr : TF, grad : TF, ?use_locking : Boolean, ?update_slots : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let update_slots = defaultArg (update_slots |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyAdagrad(var.TFOutput, accum.TFOutput, lr.TFOutput, grad.TFOutput, use_locking, update_slots, operName)
    /// <summary>
    ///               Update '*var' according to the proximal adagrad scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="gradient_accumulator">
    ///               Should be from a Variable().
    ///             </param><param name="gradient_squared_accumulator">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="global_step">
    ///               Training step number. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyAdagradDA'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.ResourceApplyAdagradDA(var : TF, gradient_accumulator : TF, gradient_squared_accumulator : TF, grad : TF, lr : TF, l1 : TF, l2 : TF, global_step : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyAdagradDA(var.TFOutput, gradient_accumulator.TFOutput, gradient_squared_accumulator.TFOutput, grad.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, global_step.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the Adam algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="m">
    ///               Should be from a Variable().
    ///             </param><param name="v">
    ///               Should be from a Variable().
    ///             </param><param name="beta1_power">
    ///               Must be a scalar.
    ///             </param><param name="beta2_power">
    ///               Must be a scalar.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="beta1">
    ///               Momentum factor. Must be a scalar.
    ///             </param><param name="beta2">
    ///               Momentum factor. Must be a scalar.
    ///             </param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyAdam'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, m, and v tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="use_nesterov">
    ///               Optional argument
    ///               If <c>True</c>, uses the nesterov update.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
    ///               $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
    ///               $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
    ///               $$variable := variable - lr_t * m_t / (\sqrt{v_t} + \epsilon)$$
    ///             </remarks>
    member this.ResourceApplyAdam(var : TF, m : TF, v : TF, beta1_power : TF, beta2_power : TF, lr : TF, beta1 : TF, beta2 : TF, epsilon : TF, grad : TF, ?use_locking : Boolean, ?use_nesterov : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let use_nesterov = defaultArg (use_nesterov |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyAdam(var.TFOutput, m.TFOutput, v.TFOutput, beta1_power.TFOutput, beta2_power.TFOutput, lr.TFOutput, beta1.TFOutput, beta2.TFOutput, epsilon.TFOutput, grad.TFOutput, use_locking, use_nesterov, operName)
    /// <summary>
    ///               Update '*var' according to the AdaMax algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="m">
    ///               Should be from a Variable().
    ///             </param><param name="v">
    ///               Should be from a Variable().
    ///             </param><param name="beta1_power">
    ///               Must be a scalar.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="beta1">
    ///               Momentum factor. Must be a scalar.
    ///             </param><param name="beta2">
    ///               Momentum factor. Must be a scalar.
    ///             </param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyAdaMax'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, m, and v tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               m_t &amp;lt;- beta1 * m_{t-1} + (1 - beta1) * g
    ///               v_t &amp;lt;- max(beta2 * v_{t-1}, abs(g))
    ///               variable &amp;lt;- variable - learning_rate / (1 - beta1^t) * m_t / (v_t + epsilon)
    ///             </remarks>
    member this.ResourceApplyAdaMax(var : TF, m : TF, v : TF, beta1_power : TF, lr : TF, beta1 : TF, beta2 : TF, epsilon : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyAdaMax(var.TFOutput, m.TFOutput, v.TFOutput, beta1_power.TFOutput, lr.TFOutput, beta1.TFOutput, beta2.TFOutput, epsilon.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the AddSign update.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="m">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="alpha">
    ///               Must be a scalar.
    ///             </param><param name="sign_decay">
    ///               Must be a scalar.
    ///             </param><param name="beta">
    ///               Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyAddSign'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and m tensors is
    ///               protected by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               m_t &amp;lt;- beta1 * m_{t-1} + (1 - beta1) * g
    ///               update &amp;lt;- (alpha + sign_decay * sign(g) *sign(m)) * g
    ///               variable &amp;lt;- variable - lr_t * update
    ///             </remarks>
    member this.ResourceApplyAddSign(var : TF, m : TF, lr : TF, alpha : TF, sign_decay : TF, beta : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyAddSign(var.TFOutput, m.TFOutput, lr.TFOutput, alpha.TFOutput, sign_decay.TFOutput, beta.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the centered RMSProp algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="mg">
    ///               Should be from a Variable().
    ///             </param><param name="ms">
    ///               Should be from a Variable().
    ///             </param><param name="mom">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay rate. Must be a scalar.
    ///             </param><param name="momentum"></param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyCenteredRMSProp'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, mg, ms, and mom tensors is
    ///               protected by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The centered RMSProp algorithm uses an estimate of the centered second moment
    ///               (i.e., the variance) for normalization, as opposed to regular RMSProp, which
    ///               uses the (uncentered) second moment. This often helps with training, but is
    ///               slightly more expensive in terms of computation and memory.
    ///               
    ///               Note that in dense implementation of this algorithm, mg, ms, and mom will
    ///               update even if the grad is zero, but in this sparse implementation, mg, ms,
    ///               and mom will not update in iterations during which the grad is zero.
    ///               
    ///               mean_square = decay * mean_square + (1-decay) * gradient ** 2
    ///               mean_grad = decay * mean_grad + (1-decay) * gradient
    ///               
    ///               Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
    ///               
    ///               mg &amp;lt;- rho * mg_{t-1} + (1-rho) * grad
    ///               ms &amp;lt;- rho * ms_{t-1} + (1-rho) * grad * grad
    ///               mom &amp;lt;- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
    ///               var &amp;lt;- var - mom
    ///             </remarks>
    member this.ResourceApplyCenteredRMSProp(var : TF, mg : TF, ms : TF, mom : TF, lr : TF, rho : TF, momentum : TF, epsilon : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyCenteredRMSProp(var.TFOutput, mg.TFOutput, ms.TFOutput, mom.TFOutput, lr.TFOutput, rho.TFOutput, momentum.TFOutput, epsilon.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the Ftrl-proximal scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="linear">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regulariation. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regulariation. Must be a scalar.
    ///             </param><param name="lr_power">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyFtrl'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               accum_new = accum + grad * grad
    ///               linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
    ///               quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
    ///               var = (sign(linear) * l1 - linear) / quadratic if |linear| &amp;gt; l1 else 0.0
    ///               accum = accum_new
    ///             </remarks>
    member this.ResourceApplyFtrl(var : TF, accum : TF, linear : TF, grad : TF, lr : TF, l1 : TF, l2 : TF, lr_power : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyFtrl(var.TFOutput, accum.TFOutput, linear.TFOutput, grad.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, lr_power.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the Ftrl-proximal scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="linear">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regulariation. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 shrinkage regulariation. Must be a scalar.
    ///             </param><param name="l2_shrinkage"></param><param name="lr_power">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyFtrlV2'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               grad_with_shrinkage = grad + 2 * l2_shrinkage * var
    ///               accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
    ///               linear += grad_with_shrinkage +
    ///               (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
    ///               quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
    ///               var = (sign(linear) * l1 - linear) / quadratic if |linear| &amp;gt; l1 else 0.0
    ///               accum = accum_new
    ///             </remarks>
    member this.ResourceApplyFtrlV2(var : TF, accum : TF, linear : TF, grad : TF, lr : TF, l1 : TF, l2 : TF, l2_shrinkage : TF, lr_power : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyFtrlV2(var.TFOutput, accum.TFOutput, linear.TFOutput, grad.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, l2_shrinkage.TFOutput, lr_power.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' by subtracting 'alpha' * 'delta' from it.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="alpha">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="delta">
    ///               The change.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyGradientDescent'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, the subtraction will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.ResourceApplyGradientDescent(var : TF, alpha : TF, delta : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyGradientDescent(var.TFOutput, alpha.TFOutput, delta.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the momentum scheme. Set use_nesterov = True if you
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="momentum">
    ///               Momentum. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyMomentum'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="use_nesterov">
    ///               Optional argument
    ///               If <c>True</c>, the tensor passed to compute grad will be
    ///               var - lr * momentum * accum, so in the end, the var you get is actually
    ///               var - lr * momentum * accum.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               want to use Nesterov momentum.
    ///               
    ///               accum = accum * momentum + grad
    ///               var -= lr * accum
    ///             </remarks>
    member this.ResourceApplyMomentum(var : TF, accum : TF, lr : TF, grad : TF, momentum : TF, ?use_locking : Boolean, ?use_nesterov : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let use_nesterov = defaultArg (use_nesterov |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyMomentum(var.TFOutput, accum.TFOutput, lr.TFOutput, grad.TFOutput, momentum.TFOutput, use_locking, use_nesterov, operName)
    /// <summary>
    ///               Update '*var' according to the AddSign update.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="m">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="logbase">
    ///               Must be a scalar.
    ///             </param><param name="sign_decay">
    ///               Must be a scalar.
    ///             </param><param name="beta">
    ///               Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyPowerSign'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and m tensors is
    ///               protected by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               m_t &amp;lt;- beta1 * m_{t-1} + (1 - beta1) * g
    ///               update &amp;lt;- exp(logbase * sign_decay * sign(g) * sign(m_t)) * g
    ///               variable &amp;lt;- variable - lr_t * update
    ///             </remarks>
    member this.ResourceApplyPowerSign(var : TF, m : TF, lr : TF, logbase : TF, sign_decay : TF, beta : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyPowerSign(var.TFOutput, m.TFOutput, lr.TFOutput, logbase.TFOutput, sign_decay.TFOutput, beta.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyProximalAdagrad'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               accum += grad * grad
    ///               prox_v = var - lr * grad * (1 / sqrt(accum))
    ///               var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
    ///             </remarks>
    member this.ResourceApplyProximalAdagrad(var : TF, accum : TF, lr : TF, l1 : TF, l2 : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyProximalAdagrad(var.TFOutput, accum.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' as FOBOS algorithm with fixed learning rate.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="alpha">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="delta">
    ///               The change.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyProximalGradientDescent'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, the subtraction will be protected by a lock;
    ///               otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               prox_v = var - alpha * delta
    ///               var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
    ///             </remarks>
    member this.ResourceApplyProximalGradientDescent(var : TF, alpha : TF, l1 : TF, l2 : TF, delta : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyProximalGradientDescent(var.TFOutput, alpha.TFOutput, l1.TFOutput, l2.TFOutput, delta.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the RMSProp algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="ms">
    ///               Should be from a Variable().
    ///             </param><param name="mom">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay rate. Must be a scalar.
    ///             </param><param name="momentum"></param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceApplyRMSProp'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, ms, and mom tensors is protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               Note that in dense implementation of this algorithm, ms and mom will
    ///               update even if the grad is zero, but in this sparse implementation, ms
    ///               and mom will not update in iterations during which the grad is zero.
    ///               
    ///               mean_square = decay * mean_square + (1-decay) * gradient ** 2
    ///               Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
    ///               
    ///               ms &amp;lt;- rho * ms_{t-1} + (1-rho) * grad * grad
    ///               mom &amp;lt;- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
    ///               var &amp;lt;- var - mom
    ///             </remarks>
    member this.ResourceApplyRMSProp(var : TF, ms : TF, mom : TF, lr : TF, rho : TF, momentum : TF, epsilon : TF, grad : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceApplyRMSProp(var.TFOutput, ms.TFOutput, mom.TFOutput, lr.TFOutput, rho.TFOutput, momentum.TFOutput, epsilon.TFOutput, grad.TFOutput, use_locking, operName)
    /// <summary>
    ///               Increments variable pointed to by 'resource' until it reaches 'limit'.
    ///             </summary><param name="resource">
    ///               Should be from a scalar <c>Variable</c> node.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceCountUpTo'.
    ///             </param><param name="limit">
    ///               If incrementing ref would bring it above limit, instead generates an
    ///               'OutOfRange' error.
    ///             </param><param name="T"></param><returns>
    ///               A copy of the input before increment. If nothing else modifies the
    ///               input, the values produced will all be distinct.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.ResourceCountUpTo(resource : TF, limit : Int64, T : TFDataType, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResourceCountUpTo(resource.TFOutput, limit, T, operName))
    /// <summary>
    ///               Gather slices from the variable pointed to by <c>resource</c> according to <c>indices</c>.
    ///             </summary><param name="resource"></param><param name="indices"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceGather'.
    ///             </param><param name="validate_indices">
    ///               Optional argument
    ///             </param><param name="dtype"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks><c>indices</c> must be an integer tensor of any dimension (usually 0-D or 1-D).
    ///               Produces an output tensor with shape <c>indices.shape + params.shape[1:]</c> where:
    ///               
    ///                <code>
    ///               # Scalar indices
    ///               output[:, ..., :] = params[indices, :, ... :]
    ///               
    ///               # Vector indices
    ///               output[i, :, ..., :] = params[indices[i], :, ... :]
    ///               
    ///               # Higher rank indices
    ///               output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
    ///                </code></remarks>
    member this.ResourceGather(resource : TF, indices : TF, dtype : TFDataType, ?validate_indices : Boolean, ?operName : String) =
        let validate_indices = defaultArg (validate_indices |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.ResourceGather(resource.TFOutput, indices.TFOutput, dtype, validate_indices, operName))
    /// <summary>
    ///               Adds sparse updates to the variable referenced by <c>resource</c>.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterAdd'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] += updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] += updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions add.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ResourceScatterAdd(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterAdd(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               Divides sparse updates into the variable referenced by <c>resource</c>.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterDiv'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] /= updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] /= updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions multiply.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ResourceScatterDiv(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterDiv(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               Reduces sparse updates into the variable referenced by <c>resource</c> using the <c>max</c> operation.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterMax'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] = max(ref[indices, ...], updates[...])
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions are combined.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ResourceScatterMax(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterMax(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               Reduces sparse updates into the variable referenced by <c>resource</c> using the <c>min</c> operation.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterMin'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] = min(ref[indices, ...], updates[...])
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions are combined.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ResourceScatterMin(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterMin(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               Multiplies sparse updates into the variable referenced by <c>resource</c>.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterMul'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] *= updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] *= updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions multiply.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ResourceScatterMul(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterMul(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               Adds sparse <c>updates</c> to individual values or slices within a given
    ///             </summary><param name="reference">
    ///               A resource handle. Must be from a VarHandleOp.
    ///             </param><param name="indices">
    ///               A Tensor. Must be one of the following types: int32, int64.
    ///               A tensor of indices into ref.
    ///             </param><param name="updates">
    ///               A Tensor. Must have the same type as ref. A tensor of
    ///               values to add to ref.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterNdAdd'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               An optional bool. Defaults to True. If True, the assignment will
    ///               be protected by a lock; otherwise the behavior is undefined,
    ///               but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               variable according to <c>indices</c>.
    ///               
    ///               <c>ref</c> is a <c>Tensor</c> with rank <c>P</c> and <c>indices</c> is a <c>Tensor</c> of rank <c>Q</c>.
    ///               
    ///               <c>indices</c> must be integer tensor, containing indices into <c>ref</c>.
    ///               It must be shape <c>[d_0, ..., d_{Q-2}, K]</c> where <c>0 &amp;lt; K &amp;lt;= P</c>.
    ///               
    ///               The innermost dimension of <c>indices</c> (with length <c>K</c>) corresponds to
    ///               indices into elements (if <c>K = P</c>) or slices (if <c>K &amp;lt; P</c>) along the <c>K</c>th
    ///               dimension of <c>ref</c>.
    ///               
    ///               <c>updates</c> is <c>Tensor</c> of rank <c>Q-1+P-K</c> with shape:
    ///               
    ///                <code>
    ///               [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
    ///                </code>
    ///               
    ///               For example, say we want to update 4 scattered elements to a rank-1 tensor to
    ///               8 elements. In Python, that update would look like this:
    ///               
    ///                <code>
    ///               ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
    ///               indices = tf.constant([[4], [3], [1] ,[7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               update = tf.scatter_nd_add(ref, indices, updates)
    ///               with tf.Session() as sess:
    ///               print sess.run(update)
    ///                </code>
    ///               
    ///               The resulting update to ref would look like this:
    ///               
    ///               [1, 12, 3, 14, 14, 6, 7, 20]
    ///               
    ///               See <c>tf.scatter_nd</c> for more details about how to make updates to
    ///               slices.
    ///             </remarks>
    member this.ResourceScatterNdAdd(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterNdAdd(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName)
    /// <summary>
    ///               Applies sparse <c>updates</c> to individual values or slices within a given
    ///             </summary><param name="reference">
    ///               A resource handle. Must be from a VarHandleOp.
    ///             </param><param name="indices">
    ///               A Tensor. Must be one of the following types: int32, int64.
    ///               A tensor of indices into ref.
    ///             </param><param name="updates">
    ///               A Tensor. Must have the same type as ref. A tensor of updated
    ///               values to add to ref.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterNdUpdate'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               An optional bool. Defaults to True. If True, the assignment will
    ///               be protected by a lock; otherwise the behavior is undefined,
    ///               but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               variable according to <c>indices</c>.
    ///               
    ///               <c>ref</c> is a <c>Tensor</c> with rank <c>P</c> and <c>indices</c> is a <c>Tensor</c> of rank <c>Q</c>.
    ///               
    ///               <c>indices</c> must be integer tensor, containing indices into <c>ref</c>.
    ///               It must be shape <c>[d_0, ..., d_{Q-2}, K]</c> where <c>0 &amp;lt; K &amp;lt;= P</c>.
    ///               
    ///               The innermost dimension of <c>indices</c> (with length <c>K</c>) corresponds to
    ///               indices into elements (if <c>K = P</c>) or slices (if <c>K &amp;lt; P</c>) along the <c>K</c>th
    ///               dimension of <c>ref</c>.
    ///               
    ///               <c>updates</c> is <c>Tensor</c> of rank <c>Q-1+P-K</c> with shape:
    ///               
    ///                <code>
    ///               [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
    ///                </code>
    ///               
    ///               For example, say we want to update 4 scattered elements to a rank-1 tensor to
    ///               8 elements. In Python, that update would look like this:
    ///               
    ///                <code>
    ///               ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    ///               indices = tf.constant([[4], [3], [1] ,[7]])
    ///               updates = tf.constant([9, 10, 11, 12])
    ///               update = tf.scatter_nd_update(ref, indices, updates)
    ///               with tf.Session() as sess:
    ///               print sess.run(update)
    ///                </code>
    ///               
    ///               The resulting update to ref would look like this:
    ///               
    ///               [1, 11, 3, 10, 9, 6, 7, 12]
    ///               
    ///               See <c>tf.scatter_nd</c> for more details about how to make updates to
    ///               slices.
    ///             </remarks>
    member this.ResourceScatterNdUpdate(reference : TF, indices : TF, updates : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterNdUpdate(reference.TFOutput, indices.TFOutput, updates.TFOutput, use_locking, operName)
    /// <summary>
    ///               Subtracts sparse updates from the variable referenced by <c>resource</c>.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterSub'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] -= updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] -= updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
    ///               
    ///               Duplicate entries are handled correctly: if multiple <c>indices</c> reference
    ///               the same location, their contributions add.
    ///               
    ///               Requires <c>updates.shape = indices.shape + ref.shape[1:]</c> or <c>updates.shape = []</c>.
    ///               
    ///               &amp;lt;div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;"&amp;gt;
    ///               &amp;lt;img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt&amp;gt;
    ///               &amp;lt;/div&amp;gt;
    ///             </remarks>
    member this.ResourceScatterSub(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterSub(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               Assigns sparse updates to the variable referenced by <c>resource</c>.
    ///             </summary><param name="resource">
    ///               Should be from a <c>Variable</c> node.
    ///             </param><param name="indices">
    ///               A tensor of indices into the first dimension of <c>ref</c>.
    ///             </param><param name="updates">
    ///               A tensor of updated values to add to <c>ref</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceScatterUpdate'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation computes
    ///               
    ///               # Scalar indices
    ///               ref[indices, ...] = updates[...]
    ///               
    ///               # Vector indices (for each i)
    ///               ref[indices[i], ...] = updates[i, ...]
    ///               
    ///               # High rank indices (for each i, ..., j)
    ///               ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
    ///             </remarks>
    member this.ResourceScatterUpdate(resource : TF, indices : TF, updates : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.ResourceScatterUpdate(resource.TFOutput, indices.TFOutput, updates.TFOutput, operName)
    /// <summary>
    ///               var: Should be from a Variable().
    ///             </summary><param name="var"></param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="accum_update">
    ///               : Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay factor. Must be a scalar.
    ///             </param><param name="epsilon">
    ///               Constant factor. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyAdadelta'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.ResourceSparseApplyAdadelta(var : TF, accum : TF, accum_update : TF, lr : TF, rho : TF, epsilon : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyAdadelta(var.TFOutput, accum.TFOutput, accum_update.TFOutput, lr.TFOutput, rho.TFOutput, epsilon.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyAdagrad'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="update_slots">
    ///               Optional argument
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var and accum as follows:
    ///               accum += grad * grad
    ///               var -= lr * grad * (1 / sqrt(accum))
    ///             </remarks>
    member this.ResourceSparseApplyAdagrad(var : TF, accum : TF, lr : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?update_slots : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let update_slots = defaultArg (update_slots |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyAdagrad(var.TFOutput, accum.TFOutput, lr.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, update_slots, operName)
    /// <summary>
    ///               Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="gradient_accumulator">
    ///               Should be from a Variable().
    ///             </param><param name="gradient_squared_accumulator">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="global_step">
    ///               Training step number. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyAdagradDA'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If True, updating of the var and accum tensors will be protected by
    ///               a lock; otherwise the behavior is undefined, but may exhibit less contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.ResourceSparseApplyAdagradDA(var : TF, gradient_accumulator : TF, gradient_squared_accumulator : TF, grad : TF, indices : TF, lr : TF, l1 : TF, l2 : TF, global_step : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyAdagradDA(var.TFOutput, gradient_accumulator.TFOutput, gradient_squared_accumulator.TFOutput, grad.TFOutput, indices.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, global_step.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update '*var' according to the centered RMSProp algorithm.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="mg">
    ///               Should be from a Variable().
    ///             </param><param name="ms">
    ///               Should be from a Variable().
    ///             </param><param name="mom">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="rho">
    ///               Decay rate. Must be a scalar.
    ///             </param><param name="momentum"></param><param name="epsilon">
    ///               Ridge term. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var, ms and mom.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyCenteredRMSProp'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var, mg, ms, and mom tensors is
    ///               protected by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The centered RMSProp algorithm uses an estimate of the centered second moment
    ///               (i.e., the variance) for normalization, as opposed to regular RMSProp, which
    ///               uses the (uncentered) second moment. This often helps with training, but is
    ///               slightly more expensive in terms of computation and memory.
    ///               
    ///               Note that in dense implementation of this algorithm, mg, ms, and mom will
    ///               update even if the grad is zero, but in this sparse implementation, mg, ms,
    ///               and mom will not update in iterations during which the grad is zero.
    ///               
    ///               mean_square = decay * mean_square + (1-decay) * gradient ** 2
    ///               mean_grad = decay * mean_grad + (1-decay) * gradient
    ///               Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
    ///               
    ///               ms &amp;lt;- rho * ms_{t-1} + (1-rho) * grad * grad
    ///               mom &amp;lt;- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
    ///               var &amp;lt;- var - mom
    ///             </remarks>
    member this.ResourceSparseApplyCenteredRMSProp(var : TF, mg : TF, ms : TF, mom : TF, lr : TF, rho : TF, momentum : TF, epsilon : TF, grad : TF, indices : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyCenteredRMSProp(var.TFOutput, mg.TFOutput, ms.TFOutput, mom.TFOutput, lr.TFOutput, rho.TFOutput, momentum.TFOutput, epsilon.TFOutput, grad.TFOutput, indices.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update relevant entries in '*var' according to the Ftrl-proximal scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="linear">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 regularization. Must be a scalar.
    ///             </param><param name="lr_power">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyFtrl'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var, accum and linear as follows:
    ///               accum_new = accum + grad * grad
    ///               linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
    ///               quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
    ///               var = (sign(linear) * l1 - linear) / quadratic if |linear| &amp;gt; l1 else 0.0
    ///               accum = accum_new
    ///             </remarks>
    member this.ResourceSparseApplyFtrl(var : TF, accum : TF, linear : TF, grad : TF, indices : TF, lr : TF, l1 : TF, l2 : TF, lr_power : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyFtrl(var.TFOutput, accum.TFOutput, linear.TFOutput, grad.TFOutput, indices.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, lr_power.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update relevant entries in '*var' according to the Ftrl-proximal scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="linear">
    ///               Should be from a Variable().
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="lr">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="l1">
    ///               L1 regularization. Must be a scalar.
    ///             </param><param name="l2">
    ///               L2 shrinkage regulariation. Must be a scalar.
    ///             </param><param name="l2_shrinkage"></param><param name="lr_power">
    ///               Scaling factor. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyFtrlV2'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               That is for rows we have grad for, we update var, accum and linear as follows:
    ///               grad_with_shrinkage = grad + 2 * l2_shrinkage * var
    ///               accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
    ///               linear += grad_with_shrinkage +
    ///               (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
    ///               quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
    ///               var = (sign(linear) * l1 - linear) / quadratic if |linear| &amp;gt; l1 else 0.0
    ///               accum = accum_new
    ///             </remarks>
    member this.ResourceSparseApplyFtrlV2(var : TF, accum : TF, linear : TF, grad : TF, indices : TF, lr : TF, l1 : TF, l2 : TF, l2_shrinkage : TF, lr_power : TF, ?use_locking : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyFtrlV2(var.TFOutput, accum.TFOutput, linear.TFOutput, grad.TFOutput, indices.TFOutput, lr.TFOutput, l1.TFOutput, l2.TFOutput, l2_shrinkage.TFOutput, lr_power.TFOutput, use_locking, operName)
    /// <summary>
    ///               Update relevant entries in '*var' and '*accum' according to the momentum scheme.
    ///             </summary><param name="var">
    ///               Should be from a Variable().
    ///             </param><param name="accum">
    ///               Should be from a Variable().
    ///             </param><param name="lr">
    ///               Learning rate. Must be a scalar.
    ///             </param><param name="grad">
    ///               The gradient.
    ///             </param><param name="indices">
    ///               A vector of indices into the first dimension of var and accum.
    ///             </param><param name="momentum">
    ///               Momentum. Must be a scalar.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'ResourceSparseApplyMomentum'.
    ///             </param><param name="use_locking">
    ///               Optional argument
    ///               If <c>True</c>, updating of the var and accum tensors will be protected
    ///               by a lock; otherwise the behavior is undefined, but may exhibit less
    ///               contention.
    ///             </param><param name="use_nesterov">
    ///               Optional argument
    ///               If <c>True</c>, the tensor passed to compute grad will be
    ///               var - lr * momentum * accum, so in the end, the var you get is actually
    ///               var - lr * momentum * accum.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               Set use_nesterov = True if you want to use Nesterov momentum.
    ///               
    ///               That is for rows we have grad for, we update var and accum as follows:
    ///               
    ///               accum = accum * momentum + grad
    ///               var -= lr * accum
    ///             </remarks>
    member this.ResourceSparseApplyMomentum(var : TF, accum : TF, lr : TF, grad : TF, indices : TF, momentum : TF, ?use_locking : Boolean, ?use_nesterov : Boolean, ?operName : String) =
        let use_locking = defaultArg (use_locking |> Option.map Nullable) (Nullable())
        let use_nesterov = defaultArg (use_nesterov |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        this.TFGraph.ResourceSparseApplyMomentum(var.TFOutput, accum.TFOutput, lr.TFOutput, grad.TFOutput, indices.TFOutput, momentum.TFOutput, use_locking, use_nesterov, operName)
    /// <summary>
    ///               Updates the table to associates keys with values.
    ///             </summary><param name="table_handle">
    ///               Handle to the table.
    ///             </param><param name="keys">
    ///               Any shape.  Keys to look up.
    ///             </param><param name="values">
    ///               Values to associate with keys.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LookupTableInsertV2'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               The tensor <c>keys</c> must be of the same type as the keys of the table.
    ///               The tensor <c>values</c> must be of the type of the table values.
    ///             </remarks>
    member this.LookupTableInsertV2(table_handle : TF, keys : TF, values : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.LookupTableInsertV2(table_handle.TFOutput, keys.TFOutput, values.TFOutput, operName)
    /// <summary>
    ///               Computes the number of elements in the given table.
    ///             </summary><param name="table_handle">
    ///               Handle to the table.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LookupTableSize'.
    ///             </param><returns>
    ///               Scalar that contains number of elements in the table.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.LookupTableSize(table_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.LookupTableSize(table_handle.TFOutput, operName))
    /// <summary>
    ///               Computes the number of elements in the given table.
    ///             </summary><param name="table_handle">
    ///               Handle to the table.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LookupTableSizeV2'.
    ///             </param><returns>
    ///               Scalar that contains number of elements in the table.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.LookupTableSizeV2(table_handle : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.LookupTableSizeV2(table_handle.TFOutput, operName))
    /// <summary>
    ///               Forwards the input to the output.
    ///             </summary><param name="input">
    ///               A boolean scalar, representing the branch predicate of the Switch op.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LoopCond'.
    ///             </param><returns>
    ///               The same tensor as <c>input</c>.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               This operator represents the loop termination condition used by the
    ///               "pivot" switches of a loop.
    ///             </remarks>
    member this.LoopCond(input : TF, ?operName : String) =
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.LoopCond(input.TFOutput, operName))
    /// <summary>
    ///               Applies lower_bound(sorted_search_values, values) along each row.
    ///             </summary><param name="sorted_inputs">
    ///               2-D Tensor where each row is ordered.
    ///             </param><param name="values">
    ///               2-D Tensor with the same numbers of rows as <c>sorted_search_values</c>. Contains
    ///               the values that will be searched for in <c>sorted_search_values</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LowerBound'.
    ///             </param><param name="out_type">
    ///               Optional argument
    ///             </param><returns>
    ///               A <c>Tensor</c> with the same shape as <c>values</c>.  It contains the first scalar index
    ///               into the last dimension where values can be inserted without changing the
    ///               ordered property.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               Each set of rows with the same index in (sorted_inputs, values) is treated
    ///               independently.  The resulting row is the equivalent of calling
    ///               <c>np.searchsorted(sorted_inputs, values, side='left')</c>.
    ///               
    ///               The result is not a global index to the entire
    ///               <c>Tensor</c>, but rather just the index in the last dimension.
    ///               
    ///               A 2-D example:
    ///               sorted_sequence = [[0, 3, 9, 9, 10],
    ///               [1, 2, 3, 4, 5]]
    ///               values = [[2, 4, 9],
    ///               [0, 2, 6]]
    ///               
    ///               result = LowerBound(sorted_sequence, values)
    ///               
    ///               result == [[1, 2, 2],
    ///               [0, 1, 5]]
    ///             </remarks>
    member this.LowerBound(sorted_inputs : TF, values : TF, ?out_type : TFDataType, ?operName : String) =
        let out_type = defaultArg (out_type |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.LowerBound(sorted_inputs.TFOutput, values.TFOutput, out_type, operName))
    /// <summary>
    ///               Local Response Normalization.
    ///             </summary><param name="input">
    ///               4-D.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LRN'.
    ///             </param><param name="depth_radius">
    ///               Optional argument
    ///               0-D.  Half-width of the 1-D normalization window.
    ///             </param><param name="bias">
    ///               Optional argument
    ///               An offset (usually positive to avoid dividing by 0).
    ///             </param><param name="alpha">
    ///               Optional argument
    ///               A scale factor, usually positive.
    ///             </param><param name="beta">
    ///               Optional argument
    ///               An exponent.
    ///             </param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               The 4-D <c>input</c> tensor is treated as a 3-D array of 1-D vectors (along the last
    ///               dimension), and each vector is normalized independently.  Within a given vector,
    ///               each component is divided by the weighted, squared sum of inputs within
    ///               <c>depth_radius</c>.  In detail,
    ///               
    ///               sqr_sum[a, b, c, d] =
    ///               sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
    ///               output = input / (bias + alpha * sqr_sum) ** beta
    ///               
    ///               For details, see [Krizhevsky et al., ImageNet classification with deep
    ///               convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
    ///             </remarks>
    member this.LRN(input : TF, ?depth_radius : Int64, ?bias : Single, ?alpha : Single, ?beta : Single, ?operName : String) =
        let depth_radius = defaultArg (depth_radius |> Option.map Nullable) (Nullable())
        let bias = defaultArg (bias |> Option.map Nullable) (Nullable())
        let alpha = defaultArg (alpha |> Option.map Nullable) (Nullable())
        let beta = defaultArg (beta |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.LRN(input.TFOutput, depth_radius, bias, alpha, beta, operName))
    /// <summary>
    ///               Gradients for Local Response Normalization.
    ///             </summary><param name="input_grads">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="input_image">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="output_image">
    ///               4-D with shape <c>[batch, height, width, channels]</c>.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'LRNGrad'.
    ///             </param><param name="depth_radius">
    ///               Optional argument
    ///               A depth radius.
    ///             </param><param name="bias">
    ///               Optional argument
    ///               An offset (usually &amp;gt; 0 to avoid dividing by 0).
    ///             </param><param name="alpha">
    ///               Optional argument
    ///               A scale factor, usually positive.
    ///             </param><param name="beta">
    ///               Optional argument
    ///               An exponent.
    ///             </param><returns>
    ///               The gradients for LRN.
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.LRNGrad(input_grads : TF, input_image : TF, output_image : TF, ?depth_radius : Int64, ?bias : Single, ?alpha : Single, ?beta : Single, ?operName : String) =
        let depth_radius = defaultArg (depth_radius |> Option.map Nullable) (Nullable())
        let bias = defaultArg (bias |> Option.map Nullable) (Nullable())
        let alpha = defaultArg (alpha |> Option.map Nullable) (Nullable())
        let beta = defaultArg (beta |> Option.map Nullable) (Nullable())
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.LRNGrad(input_grads.TFOutput, input_image.TFOutput, output_image.TFOutput, depth_radius, bias, alpha, beta, operName))
    /// <summary>
    ///               Makes a new iterator from the given <c>dataset</c> and stores it in <c>iterator</c>.
    ///             </summary><param name="dataset"></param><param name="iterator"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MakeIterator'.
    ///             </param><returns>
    ///               Returns the description of the operation
    ///             </returns><remarks>
    ///               This operation may be executed multiple times. Each execution will reset the
    ///               iterator in <c>iterator</c> to the first element of <c>dataset</c>.
    ///             </remarks>
    member this.MakeIterator(dataset : TF, iterator : TF, ?operName : String) =
        let operName = defaultArg operName null
        this.TFGraph.MakeIterator(dataset.TFOutput, iterator.TFOutput, operName)
    /// <summary>
    ///               Op removes all elements in the underlying container.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapClear'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.MapClear(dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.MapClear(dtypes, capacity, memory_limit, container, shared_name, operName)
    /// <summary>
    ///               Op returns the number of incomplete elements in the underlying container.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapIncompleteSize'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.MapIncompleteSize(dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.MapIncompleteSize(dtypes, capacity, memory_limit, container, shared_name, operName))
    /// <summary>
    ///               Op peeks at the values at the specified key.  If the
    ///             </summary><param name="key"></param><param name="indices"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapPeek'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               underlying container does not contain this key
    ///               this op will block until it does.
    ///             </remarks>
    member this.MapPeek(key : TF, indices : TF, dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.MapPeek(key.TFOutput, indices.TFOutput, dtypes, capacity, memory_limit, container, shared_name, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Op returns the number of elements in the underlying container.
    ///             </summary><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapSize'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns>
    member this.MapSize(dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        TF(this.TFGraph, this.TFGraph.MapSize(dtypes, capacity, memory_limit, container, shared_name, operName))
    /// <summary>
    ///               Stage (key, values) in the underlying container which behaves like a hashtable.
    ///             </summary><param name="key">
    ///               int64
    ///             </param><param name="indices"></param><param name="values">
    ///               a list of tensors
    ///               dtypes A list of data types that inserted values should adhere to.
    ///             </param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapStage'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///               Maximum number of elements in the Staging Area. If &amp;gt; 0, inserts
    ///               on the container will block when the capacity is reached.
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///               If non-empty, this queue is placed in the given container. Otherwise,
    ///               a default container is used.
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///               It is necessary to match this name to the matching Unstage Op.
    ///             </param><param name="dtypes"></param><returns>
    ///               Returns the description of the operation
    ///             </returns>
    member this.MapStage(key : TF, indices : TF, values : TF[], dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.MapStage(key.TFOutput, indices.TFOutput, values |> Array.map (fun x -> x.TFOutput), dtypes, capacity, memory_limit, container, shared_name, operName)
    /// <summary>
    ///               Op removes and returns the values associated with the key
    ///             </summary><param name="key"></param><param name="indices"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapUnstage'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               The TFOperation can be fetched from the resulting TFOutput, by fethching the Operation property from the result.
    ///             </returns><remarks>
    ///               from the underlying container.   If the underlying container
    ///               does not contain this key, the op will block until it does.
    ///             </remarks>
    member this.MapUnstage(key : TF, indices : TF, dtypes : TFDataType[], ?capacity : Int64, ?memory_limit : Int64, ?container : String, ?shared_name : String, ?operName : String) =
        let capacity = defaultArg (capacity |> Option.map Nullable) (Nullable())
        let memory_limit = defaultArg (memory_limit |> Option.map Nullable) (Nullable())
        let container = defaultArg container null
        let shared_name = defaultArg shared_name null
        let operName = defaultArg operName null
        this.TFGraph.MapUnstage(key.TFOutput, indices.TFOutput, dtypes, capacity, memory_limit, container, shared_name, operName) |> Array.map (fun i -> TF(this.TFGraph, i))
    /// <summary>
    ///               Op removes and returns a random (key, value)
    ///             </summary><param name="indices"></param><param name="operName">
    ///               If specified, the created operation in the graph will be this one, otherwise it will be named 'MapUnstageNoKey'.
    ///             </param><param name="capacity">
    ///               Optional argument
    ///             </param><param name="memory_limit">
    ///               Optional argument
    ///             </param><param name="container">
    ///               Optional argument
    ///             </param><param name="shared_name">
    ///               Optional argument
    ///             </param><param name="dtypes"></param><returns>
    ///               Returns a tuple with multiple values, as follows:
    ///               key:
    ///               values:
    ///               The TFOperation can be fetched from any of the TFOutputs returned in the tuple values, by fethching the Operation property.
    ///             </returns><remarks>
    ///               from the underlying container.   If the underlying container
    ///               does not contain elements, the op will block until it does.
    ///             </remarks>