| Package | Description |
|---|---|
| org.tensorflow.op | |
| org.tensorflow.op.core |
| Modifier and Type | Method and Description |
|---|---|
Scope |
Ops.scope()
Returns the current
scope of this API |
Scope |
Scope.withName(String opName)
Return a new scope that uses the provided name for an op.
|
Scope |
Scope.withSubScope(String childScopeName)
Returns a new scope where added operations will have the provided name prefix.
|
| Modifier and Type | Method and Description |
|---|---|
static OptionalNone |
OptionalNone.create(Scope scope)
Factory method to create a class to wrap a new OptionalNone operation to the graph.
|
static Timestamp |
Timestamp.create(Scope scope)
Factory method to create a class to wrap a new Timestamp operation to the graph.
|
static NoOp |
NoOp.create(Scope scope)
Factory method to create a class to wrap a new NoOp operation to the graph.
|
static Fact |
Fact.create(Scope scope)
Factory method to create a class to wrap a new Fact operation to the graph.
|
static ControlTrigger |
ControlTrigger.create(Scope scope)
Factory method to create a class to wrap a new ControlTrigger operation to the graph.
|
static Abort |
Abort.create(Scope scope,
Abort.Options... options)
Factory method to create a class to wrap a new Abort operation to the graph.
|
static Constant<Boolean> |
Constant.create(Scope scope,
boolean data)
Creates a constant containing a single
boolean element. |
static Constant<Boolean> |
Constant.create(Scope scope,
boolean[] data)
Creates a rank-1 constant of
boolean elements. |
static Constant<Boolean> |
Constant.create(Scope scope,
boolean[][] data)
Creates a rank-2 constant of
boolean elements. |
static Constant<Boolean> |
Constant.create(Scope scope,
boolean[][][] data)
Creates a rank-3 constant of
boolean elements. |
static Constant<Boolean> |
Constant.create(Scope scope,
boolean[][][][] data)
Creates a rank-4 constant of
boolean elements. |
static Constant<Boolean> |
Constant.create(Scope scope,
boolean[][][][][] data)
Creates a rank-5 constant of
boolean elements. |
static Constant<Boolean> |
Constant.create(Scope scope,
boolean[][][][][][] data)
Creates a rank-6 constant of
boolean elements. |
static BoostedTreesEnsembleResourceHandleOp |
BoostedTreesEnsembleResourceHandleOp.create(Scope scope,
BoostedTreesEnsembleResourceHandleOp.Options... options)
Factory method to create a class to wrap a new BoostedTreesEnsembleResourceHandleOp operation to the graph.
|
static BoostedTreesQuantileStreamResourceHandleOp |
BoostedTreesQuantileStreamResourceHandleOp.create(Scope scope,
BoostedTreesQuantileStreamResourceHandleOp.Options... options)
Factory method to create a class to wrap a new BoostedTreesQuantileStreamResourceHandleOp operation to the graph.
|
static Constant<String> |
Constant.create(Scope scope,
byte[] data)
Creates a constant containing a single
String element, represented as an array of bytes. |
static Constant<String> |
Constant.create(Scope scope,
byte[][] data)
Creates a rank-1 constant of
String elements, each represented as an array of bytes. |
static Constant<String> |
Constant.create(Scope scope,
byte[][][] data)
Creates a rank-2 constant of
String elements, each represented as an array of bytes. |
static Constant<String> |
Constant.create(Scope scope,
byte[][][][] data)
Creates a rank-3 constant of
String elements, each represented as an array of bytes. |
static Constant<String> |
Constant.create(Scope scope,
byte[][][][][] data)
Creates a rank-4 constant of
String elements, each represented as an array of bytes. |
static Constant<String> |
Constant.create(Scope scope,
byte[][][][][][] data)
Creates a rank-5 constant of
String elements, each represented as an array of bytes. |
static <T,U> HashTable |
HashTable.create(Scope scope,
Class<T> keyDtype,
Class<U> valueDtype,
HashTable.Options... options)
Factory method to create a class to wrap a new HashTable operation to the graph.
|
static <T,U> MutableHashTable |
MutableHashTable.create(Scope scope,
Class<T> keyDtype,
Class<U> valueDtype,
MutableHashTable.Options... options)
Factory method to create a class to wrap a new MutableHashTable operation to the graph.
|
static <T,U> MutableHashTableOfTensors |
MutableHashTableOfTensors.create(Scope scope,
Class<T> keyDtype,
Class<U> valueDtype,
MutableHashTableOfTensors.Options... options)
Factory method to create a class to wrap a new MutableHashTableOfTensors operation to the graph.
|
static <T> Constant<T> |
Constant.create(Scope scope,
Class<T> type,
long[] shape,
ByteBuffer data)
Create a constant with data from the given buffer.
|
static <T extends Number> |
CollectiveBcastRecv.create(Scope scope,
Class<T> T,
Long groupSize,
Long groupKey,
Long instanceKey,
Shape shape)
Factory method to create a class to wrap a new CollectiveBcastRecv operation to the graph.
|
static <T> Placeholder<T> |
Placeholder.create(Scope scope,
Class<T> dtype,
Placeholder.Options... options)
Factory method to create a class to wrap a new Placeholder operation to the graph.
|
static <T> PlaceholderV2<T> |
PlaceholderV2.create(Scope scope,
Class<T> dtype,
Shape shape)
Factory method to create a class to wrap a new PlaceholderV2 operation to the graph.
|
static <T> ConditionalAccumulator |
ConditionalAccumulator.create(Scope scope,
Class<T> dtype,
Shape shape,
ConditionalAccumulator.Options... options)
Factory method to create a class to wrap a new ConditionalAccumulator operation to the graph.
|
static <T> SparseConditionalAccumulator |
SparseConditionalAccumulator.create(Scope scope,
Class<T> dtype,
Shape shape,
SparseConditionalAccumulator.Options... options)
Factory method to create a class to wrap a new SparseConditionalAccumulator operation to the graph.
|
static <T> ImmutableConst<T> |
ImmutableConst.create(Scope scope,
Class<T> dtype,
Shape shape,
String memoryRegionName)
Factory method to create a class to wrap a new ImmutableConst operation to the graph.
|
static <T> VarHandleOp |
VarHandleOp.create(Scope scope,
Class<T> dtype,
Shape shape,
VarHandleOp.Options... options)
Factory method to create a class to wrap a new VarHandleOp operation to the graph.
|
static Constant<Double> |
Constant.create(Scope scope,
double data)
Creates a constant containing a single
double element. |
static Constant<Double> |
Constant.create(Scope scope,
double[] data)
Creates a rank-1 constant of
double elements. |
static Constant<Double> |
Constant.create(Scope scope,
double[][] data)
Creates a rank-2 constant of
double elements. |
static Constant<Double> |
Constant.create(Scope scope,
double[][][] data)
Creates a rank-3 constant of
double elements. |
static Constant<Double> |
Constant.create(Scope scope,
double[][][][] data)
Creates a rank-4 constant of
double elements. |
static Constant<Double> |
Constant.create(Scope scope,
double[][][][][] data)
Creates a rank-5 constant of
double elements. |
static Constant<Double> |
Constant.create(Scope scope,
double[][][][][][] data)
Creates a rank-6 constant of
double elements. |
static Constant<Float> |
Constant.create(Scope scope,
float data)
Creates a constant containing a single
float element. |
static Constant<Float> |
Constant.create(Scope scope,
float[] data)
Creates a rank-1 constant of
float elements. |
static Constant<Float> |
Constant.create(Scope scope,
float[][] data)
Creates a rank-2 constant of
float elements. |
static Constant<Float> |
Constant.create(Scope scope,
float[][][] data)
Creates a rank-3 constant of
float elements. |
static Constant<Float> |
Constant.create(Scope scope,
float[][][][] data)
Creates a rank-4 constant of
float elements. |
static Constant<Float> |
Constant.create(Scope scope,
float[][][][][] data)
Creates a rank-5 constant of
float elements. |
static Constant<Float> |
Constant.create(Scope scope,
float[][][][][][] data)
Creates a rank-6 constant of
float elements. |
static IdentityReader |
IdentityReader.create(Scope scope,
IdentityReader.Options... options)
Factory method to create a class to wrap a new IdentityReader operation to the graph.
|
static Constant<Integer> |
Constant.create(Scope scope,
int data)
Creates a constant containing a single
int element. |
static Constant<Integer> |
Constant.create(Scope scope,
int[] data)
Creates a rank-1 constant of
int elements. |
static Constant<Integer> |
Constant.create(Scope scope,
int[][] data)
Creates a rank-2 constant of
int elements. |
static Constant<Integer> |
Constant.create(Scope scope,
int[][][] data)
Creates a rank-3 constant of
int elements. |
static Constant<Integer> |
Constant.create(Scope scope,
int[][][][] data)
Creates a rank-4 constant of
int elements. |
static Constant<Integer> |
Constant.create(Scope scope,
int[][][][][] data)
Creates a rank-5 constant of
int elements. |
static Constant<Integer> |
Constant.create(Scope scope,
int[][][][][][] data)
Creates a rank-6 constant of
int elements. |
static Gradients |
Gradients.create(Scope scope,
Iterable<? extends Operand<?>> y,
Iterable<? extends Operand<?>> x,
Gradients.Options... options)
Adds gradients computation ops to the graph according to scope.
|
static IdentityN |
IdentityN.create(Scope scope,
Iterable<Operand<?>> input)
Factory method to create a class to wrap a new IdentityN operation to the graph.
|
static OptionalFromValue |
OptionalFromValue.create(Scope scope,
Iterable<Operand<?>> components)
Factory method to create a class to wrap a new OptionalFromValue operation to the graph.
|
static ZipDataset |
ZipDataset.create(Scope scope,
Iterable<Operand<?>> inputDatasets,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ZipDataset operation to the graph.
|
static RemoteFusedGraphExecute |
RemoteFusedGraphExecute.create(Scope scope,
Iterable<Operand<?>> inputs,
List<Class<?>> Toutputs,
String serializedRemoteFusedGraphExecuteInfo)
Factory method to create a class to wrap a new RemoteFusedGraphExecute operation to the graph.
|
static TensorSliceDataset |
TensorSliceDataset.create(Scope scope,
Iterable<Operand<?>> components,
List<Shape> outputShapes)
Factory method to create a class to wrap a new TensorSliceDataset operation to the graph.
|
static TensorDataset |
TensorDataset.create(Scope scope,
Iterable<Operand<?>> components,
List<Shape> outputShapes)
Factory method to create a class to wrap a new TensorDataset operation to the graph.
|
static Batch |
Batch.create(Scope scope,
Iterable<Operand<?>> inTensors,
Long numBatchThreads,
Long maxBatchSize,
Long batchTimeoutMicros,
Long gradTimeoutMicros,
Batch.Options... options)
Factory method to create a class to wrap a new Batch operation to the graph.
|
static Stage |
Stage.create(Scope scope,
Iterable<Operand<?>> values,
Stage.Options... options)
Factory method to create a class to wrap a new Stage operation to the graph.
|
static StringFormat |
StringFormat.create(Scope scope,
Iterable<Operand<?>> inputs,
StringFormat.Options... options)
Factory method to create a class to wrap a new StringFormat operation to the graph.
|
static EagerPyFunc |
EagerPyFunc.create(Scope scope,
Iterable<Operand<?>> input,
String token,
List<Class<?>> Tout)
Factory method to create a class to wrap a new EagerPyFunc operation to the graph.
|
static SdcaShrinkL1 |
SdcaShrinkL1.create(Scope scope,
Iterable<Operand<Float>> weights,
Float l1,
Float l2)
Factory method to create a class to wrap a new SdcaShrinkL1 operation to the graph.
|
static BoostedTreesBucketize |
BoostedTreesBucketize.create(Scope scope,
Iterable<Operand<Float>> floatValues,
Iterable<Operand<Float>> bucketBoundaries)
Factory method to create a class to wrap a new BoostedTreesBucketize operation to the graph.
|
static BoostedTreesMakeQuantileSummaries |
BoostedTreesMakeQuantileSummaries.create(Scope scope,
Iterable<Operand<Float>> floatValues,
Operand<Float> exampleWeights,
Operand<Float> epsilon)
Factory method to create a class to wrap a new BoostedTreesMakeQuantileSummaries operation to the graph.
|
static <T> DynamicStitch<T> |
DynamicStitch.create(Scope scope,
Iterable<Operand<Integer>> indices,
Operand<T> data)
Factory method to create a class to wrap a new DynamicStitch operation to the graph.
|
static <T> ParallelDynamicStitch<T> |
ParallelDynamicStitch.create(Scope scope,
Iterable<Operand<Integer>> indices,
Operand<T> data)
Factory method to create a class to wrap a new ParallelDynamicStitch operation to the graph.
|
static <T,U> SparseCross<T> |
SparseCross.create(Scope scope,
Iterable<Operand<Long>> indices,
Iterable<Operand<?>> values,
Iterable<Operand<Long>> shapes,
Iterable<Operand<?>> denseInputs,
Boolean hashedOutput,
Long numBuckets,
Long hashKey,
Class<T> outType,
Class<U> internalType)
Factory method to create a class to wrap a new SparseCross operation to the graph.
|
static SdcaOptimizer |
SdcaOptimizer.create(Scope scope,
Iterable<Operand<Long>> sparseExampleIndices,
Iterable<Operand<Long>> sparseFeatureIndices,
Iterable<Operand<Float>> sparseFeatureValues,
Iterable<Operand<Float>> denseFeatures,
Operand<Float> exampleWeights,
Operand<Float> exampleLabels,
Iterable<Operand<Long>> sparseIndices,
Iterable<Operand<Float>> sparseWeights,
Iterable<Operand<Float>> denseWeights,
Operand<Float> exampleStateData,
String lossType,
Float l1,
Float l2,
Long numLossPartitions,
Long numInnerIterations,
SdcaOptimizer.Options... options)
Factory method to create a class to wrap a new SdcaOptimizer operation to the graph.
|
static <T> SparseConcat<T> |
SparseConcat.create(Scope scope,
Iterable<Operand<Long>> indices,
Operand<T> values,
Iterable<Operand<Long>> shapes,
Long concatDim)
Factory method to create a class to wrap a new SparseConcat operation to the graph.
|
static MergeSummary |
MergeSummary.create(Scope scope,
Iterable<Operand<String>> inputs)
Factory method to create a class to wrap a new MergeSummary operation to the graph.
|
static StringJoin |
StringJoin.create(Scope scope,
Iterable<Operand<String>> inputs,
StringJoin.Options... options)
Factory method to create a class to wrap a new StringJoin operation to the graph.
|
static Barrier |
Barrier.create(Scope scope,
List<Class<?>> componentTypes,
Barrier.Options... options)
Factory method to create a class to wrap a new Barrier operation to the graph.
|
static FIFOQueue |
FIFOQueue.create(Scope scope,
List<Class<?>> componentTypes,
FIFOQueue.Options... options)
Factory method to create a class to wrap a new FIFOQueue operation to the graph.
|
static AnonymousIterator |
AnonymousIterator.create(Scope scope,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new AnonymousIterator operation to the graph.
|
static PriorityQueue |
PriorityQueue.create(Scope scope,
List<Class<?>> componentTypes,
List<Shape> shapes,
PriorityQueue.Options... options)
Factory method to create a class to wrap a new PriorityQueue operation to the graph.
|
static MapClear |
MapClear.create(Scope scope,
List<Class<?>> dtypes,
MapClear.Options... options)
Factory method to create a class to wrap a new MapClear operation to the graph.
|
static MapIncompleteSize |
MapIncompleteSize.create(Scope scope,
List<Class<?>> dtypes,
MapIncompleteSize.Options... options)
Factory method to create a class to wrap a new MapIncompleteSize operation to the graph.
|
static MapSize |
MapSize.create(Scope scope,
List<Class<?>> dtypes,
MapSize.Options... options)
Factory method to create a class to wrap a new MapSize operation to the graph.
|
static OrderedMapClear |
OrderedMapClear.create(Scope scope,
List<Class<?>> dtypes,
OrderedMapClear.Options... options)
Factory method to create a class to wrap a new OrderedMapClear operation to the graph.
|
static OrderedMapIncompleteSize |
OrderedMapIncompleteSize.create(Scope scope,
List<Class<?>> dtypes,
OrderedMapIncompleteSize.Options... options)
Factory method to create a class to wrap a new OrderedMapIncompleteSize operation to the graph.
|
static OrderedMapSize |
OrderedMapSize.create(Scope scope,
List<Class<?>> dtypes,
OrderedMapSize.Options... options)
Factory method to create a class to wrap a new OrderedMapSize operation to the graph.
|
static PaddingFIFOQueue |
PaddingFIFOQueue.create(Scope scope,
List<Class<?>> componentTypes,
PaddingFIFOQueue.Options... options)
Factory method to create a class to wrap a new PaddingFIFOQueue operation to the graph.
|
static RandomShuffleQueue |
RandomShuffleQueue.create(Scope scope,
List<Class<?>> componentTypes,
RandomShuffleQueue.Options... options)
Factory method to create a class to wrap a new RandomShuffleQueue operation to the graph.
|
static StageClear |
StageClear.create(Scope scope,
List<Class<?>> dtypes,
StageClear.Options... options)
Factory method to create a class to wrap a new StageClear operation to the graph.
|
static StageSize |
StageSize.create(Scope scope,
List<Class<?>> dtypes,
StageSize.Options... options)
Factory method to create a class to wrap a new StageSize operation to the graph.
|
static Unstage |
Unstage.create(Scope scope,
List<Class<?>> dtypes,
Unstage.Options... options)
Factory method to create a class to wrap a new Unstage operation to the graph.
|
static MultiDeviceIterator |
MultiDeviceIterator.create(Scope scope,
List<String> devices,
String sharedName,
String container,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new MultiDeviceIterator operation to the graph.
|
static LMDBReader |
LMDBReader.create(Scope scope,
LMDBReader.Options... options)
Factory method to create a class to wrap a new LMDBReader operation to the graph.
|
static Constant<Long> |
Constant.create(Scope scope,
long data)
Creates a constant containing a single
long element. |
static Constant<Long> |
Constant.create(Scope scope,
long[] data)
Creates a rank-1 constant of
long elements. |
static Constant<Long> |
Constant.create(Scope scope,
long[][] data)
Creates a rank-2 constant of
long elements. |
static Constant<Long> |
Constant.create(Scope scope,
long[][][] data)
Creates a rank-3 constant of
long elements. |
static Constant<Long> |
Constant.create(Scope scope,
long[][][][] data)
Creates a rank-4 constant of
long elements. |
static Constant<Long> |
Constant.create(Scope scope,
long[][][][][] data)
Creates a rank-5 constant of
long elements. |
static Constant<Long> |
Constant.create(Scope scope,
long[][][][][][] data)
Creates a rank-6 constant of
long elements. |
static Constant<Double> |
Constant.create(Scope scope,
long[] shape,
DoubleBuffer data)
Create a
DataType.DOUBLE constant with data from the given buffer. |
static Constant<Float> |
Constant.create(Scope scope,
long[] shape,
FloatBuffer data)
Create a
DataType.FLOAT constant with data from the given buffer. |
static Constant<Integer> |
Constant.create(Scope scope,
long[] shape,
IntBuffer data)
Create a
DataType.INT32 constant with data from the given buffer. |
static Constant<Long> |
Constant.create(Scope scope,
long[] shape,
LongBuffer data)
Create a
DataType.INT64 constant with data from the given buffer. |
static FixedLengthRecordReader |
FixedLengthRecordReader.create(Scope scope,
Long recordBytes,
FixedLengthRecordReader.Options... options)
Factory method to create a class to wrap a new FixedLengthRecordReader operation to the graph.
|
static ExperimentalThreadPoolHandle |
ExperimentalThreadPoolHandle.create(Scope scope,
Long numThreads,
String displayName,
ExperimentalThreadPoolHandle.Options... options)
Factory method to create a class to wrap a new ExperimentalThreadPoolHandle operation to the graph.
|
static MutexV2 |
MutexV2.create(Scope scope,
MutexV2.Options... options)
Factory method to create a class to wrap a new MutexV2 operation to the graph.
|
static <T> Constant<T> |
Constant.create(Scope scope,
Object object,
Class<T> type)
Create a constant from a Java object.
|
static ConsumeMutexLock |
ConsumeMutexLock.create(Scope scope,
Operand<?> mutexLock)
Factory method to create a class to wrap a new ConsumeMutexLock operation to the graph.
|
static IteratorToStringHandle |
IteratorToStringHandle.create(Scope scope,
Operand<?> resourceHandle)
Factory method to create a class to wrap a new IteratorToStringHandle operation to the graph.
|
static QueueIsClosedV2 |
QueueIsClosedV2.create(Scope scope,
Operand<?> handle)
Factory method to create a class to wrap a new QueueIsClosedV2 operation to the graph.
|
static BatchIFFT3D |
BatchIFFT3D.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new BatchIFFT3D operation to the graph.
|
static MutexLock |
MutexLock.create(Scope scope,
Operand<?> mutex)
Factory method to create a class to wrap a new MutexLock operation to the graph.
|
static QueueSize |
QueueSize.create(Scope scope,
Operand<?> handle)
Factory method to create a class to wrap a new QueueSize operation to the graph.
|
static ExperimentalIdentityIndexedDataset |
ExperimentalIdentityIndexedDataset.create(Scope scope,
Operand<?> size)
Factory method to create a class to wrap a new ExperimentalIdentityIndexedDataset operation to the graph.
|
static VarIsInitializedOp |
VarIsInitializedOp.create(Scope scope,
Operand<?> resource)
Factory method to create a class to wrap a new VarIsInitializedOp operation to the graph.
|
static BatchIFFT2D |
BatchIFFT2D.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new BatchIFFT2D operation to the graph.
|
static IsBoostedTreesEnsembleInitialized |
IsBoostedTreesEnsembleInitialized.create(Scope scope,
Operand<?> treeEnsembleHandle)
Factory method to create a class to wrap a new IsBoostedTreesEnsembleInitialized operation to the graph.
|
static ExperimentalFunctionBufferingResourceReset |
ExperimentalFunctionBufferingResourceReset.create(Scope scope,
Operand<?> functionBufferResource)
Factory method to create a class to wrap a new ExperimentalFunctionBufferingResourceReset operation to the graph.
|
static BatchFFT3D |
BatchFFT3D.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new BatchFFT3D operation to the graph.
|
static TensorListLength |
TensorListLength.create(Scope scope,
Operand<?> inputHandle)
Factory method to create a class to wrap a new TensorListLength operation to the graph.
|
static MultiDeviceIteratorToStringHandle |
MultiDeviceIteratorToStringHandle.create(Scope scope,
Operand<?> multiDeviceIterator)
Factory method to create a class to wrap a new MultiDeviceIteratorToStringHandle operation to the graph.
|
static TensorArrayClose |
TensorArrayClose.create(Scope scope,
Operand<?> handle)
Factory method to create a class to wrap a new TensorArrayClose operation to the graph.
|
static IsBoostedTreesQuantileStreamResourceInitialized |
IsBoostedTreesQuantileStreamResourceInitialized.create(Scope scope,
Operand<?> quantileStreamResourceHandle)
Factory method to create a class to wrap a new IsBoostedTreesQuantileStreamResourceInitialized operation to the graph.
|
static ExperimentalIteratorGetDevice |
ExperimentalIteratorGetDevice.create(Scope scope,
Operand<?> resource)
Factory method to create a class to wrap a new ExperimentalIteratorGetDevice operation to the graph.
|
static StatsAggregatorSummary |
StatsAggregatorSummary.create(Scope scope,
Operand<?> iterator)
Factory method to create a class to wrap a new StatsAggregatorSummary operation to the graph.
|
static ReaderSerializeState |
ReaderSerializeState.create(Scope scope,
Operand<?> readerHandle)
Factory method to create a class to wrap a new ReaderSerializeState operation to the graph.
|
static BatchFFT2D |
BatchFFT2D.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new BatchFFT2D operation to the graph.
|
static LookupTableSize |
LookupTableSize.create(Scope scope,
Operand<?> tableHandle)
Factory method to create a class to wrap a new LookupTableSize operation to the graph.
|
static DatasetToGraph |
DatasetToGraph.create(Scope scope,
Operand<?> inputDataset)
Factory method to create a class to wrap a new DatasetToGraph operation to the graph.
|
static ReaderNumRecordsProduced |
ReaderNumRecordsProduced.create(Scope scope,
Operand<?> readerHandle)
Factory method to create a class to wrap a new ReaderNumRecordsProduced operation to the graph.
|
static SinkDataset |
SinkDataset.create(Scope scope,
Operand<?> inputDataset)
Factory method to create a class to wrap a new SinkDataset operation to the graph.
|
static BatchIFFT |
BatchIFFT.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new BatchIFFT operation to the graph.
|
static ReaderNumWorkUnitsCompleted |
ReaderNumWorkUnitsCompleted.create(Scope scope,
Operand<?> readerHandle)
Factory method to create a class to wrap a new ReaderNumWorkUnitsCompleted operation to the graph.
|
static BatchFFT |
BatchFFT.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new BatchFFT operation to the graph.
|
static BoostedTreesGetEnsembleStates |
BoostedTreesGetEnsembleStates.create(Scope scope,
Operand<?> treeEnsembleHandle)
Factory method to create a class to wrap a new BoostedTreesGetEnsembleStates operation to the graph.
|
static SerializeIterator |
SerializeIterator.create(Scope scope,
Operand<?> resourceHandle)
Factory method to create a class to wrap a new SerializeIterator operation to the graph.
|
static ReaderReset |
ReaderReset.create(Scope scope,
Operand<?> readerHandle)
Factory method to create a class to wrap a new ReaderReset operation to the graph.
|
static VariableShape<Integer> |
VariableShape.create(Scope scope,
Operand<?> input)
Factory method to create a class to wrap a new VariableShape operation to the graph, using default output types.
|
static BoostedTreesSerializeEnsemble |
BoostedTreesSerializeEnsemble.create(Scope scope,
Operand<?> treeEnsembleHandle)
Factory method to create a class to wrap a new BoostedTreesSerializeEnsemble operation to the graph.
|
static FlushSummaryWriter |
FlushSummaryWriter.create(Scope scope,
Operand<?> writer)
Factory method to create a class to wrap a new FlushSummaryWriter operation to the graph.
|
static OptionalHasValue |
OptionalHasValue.create(Scope scope,
Operand<?> optional)
Factory method to create a class to wrap a new OptionalHasValue operation to the graph.
|
static CloseSummaryWriter |
CloseSummaryWriter.create(Scope scope,
Operand<?> writer)
Factory method to create a class to wrap a new CloseSummaryWriter operation to the graph.
|
static <T> ReadVariableOp<T> |
ReadVariableOp.create(Scope scope,
Operand<?> resource,
Class<T> dtype)
Factory method to create a class to wrap a new ReadVariableOp operation to the graph.
|
static <T> TensorListPopBack<T> |
TensorListPopBack.create(Scope scope,
Operand<?> inputHandle,
Class<T> elementDtype)
Factory method to create a class to wrap a new TensorListPopBack operation to the graph.
|
static <T extends Number> |
TensorListElementShape.create(Scope scope,
Operand<?> inputHandle,
Class<T> shapeType)
Factory method to create a class to wrap a new TensorListElementShape operation to the graph.
|
static <T extends Number> |
VariableShape.create(Scope scope,
Operand<?> input,
Class<T> outType)
Factory method to create a class to wrap a new VariableShape operation to the graph.
|
static <T,U> LookupTableExport<T,U> |
LookupTableExport.create(Scope scope,
Operand<?> tableHandle,
Class<T> Tkeys,
Class<U> Tvalues)
Factory method to create a class to wrap a new LookupTableExport operation to the graph.
|
static <T> TensorListStack<T> |
TensorListStack.create(Scope scope,
Operand<?> inputHandle,
Class<T> elementDtype,
TensorListStack.Options... options)
Factory method to create a class to wrap a new TensorListStack operation to the graph.
|
static DestroyResourceOp |
DestroyResourceOp.create(Scope scope,
Operand<?> resource,
DestroyResourceOp.Options... options)
Factory method to create a class to wrap a new DestroyResourceOp operation to the graph.
|
static Gradients |
Gradients.create(Scope scope,
Operand<?> y,
Iterable<? extends Operand<?>> x,
Gradients.Options... options)
Adds gradients computation ops to the graph according to scope.
|
static EnqueueInQueueDataset |
EnqueueInQueueDataset.create(Scope scope,
Operand<?> queue,
Iterable<Operand<?>> components)
Factory method to create a class to wrap a new EnqueueInQueueDataset operation to the graph.
|
static ExperimentalDirectedInterleaveDataset |
ExperimentalDirectedInterleaveDataset.create(Scope scope,
Operand<?> selectorInputDataset,
Iterable<Operand<?>> dataInputDatasets,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalDirectedInterleaveDataset operation to the graph.
|
static QueueEnqueue |
QueueEnqueue.create(Scope scope,
Operand<?> handle,
Iterable<Operand<?>> components,
QueueEnqueue.Options... options)
Factory method to create a class to wrap a new QueueEnqueue operation to the graph.
|
static QueueEnqueueMany |
QueueEnqueueMany.create(Scope scope,
Operand<?> handle,
Iterable<Operand<?>> components,
QueueEnqueueMany.Options... options)
Factory method to create a class to wrap a new QueueEnqueueMany operation to the graph.
|
static BoostedTreesQuantileStreamResourceAddSummaries |
BoostedTreesQuantileStreamResourceAddSummaries.create(Scope scope,
Operand<?> quantileStreamResourceHandle,
Iterable<Operand<Float>> summaries)
Factory method to create a class to wrap a new BoostedTreesQuantileStreamResourceAddSummaries operation to the graph.
|
static BoostedTreesPredict |
BoostedTreesPredict.create(Scope scope,
Operand<?> treeEnsembleHandle,
Iterable<Operand<Integer>> bucketizedFeatures,
Long logitsDimension)
Factory method to create a class to wrap a new BoostedTreesPredict operation to the graph.
|
static BoostedTreesExampleDebugOutputs |
BoostedTreesExampleDebugOutputs.create(Scope scope,
Operand<?> treeEnsembleHandle,
Iterable<Operand<Integer>> bucketizedFeatures,
Long logitsDimension)
Factory method to create a class to wrap a new BoostedTreesExampleDebugOutputs operation to the graph.
|
static ExperimentalFunctionBufferingResourceGetNext |
ExperimentalFunctionBufferingResourceGetNext.create(Scope scope,
Operand<?> functionBufferResource,
List<Class<?>> outputTypes)
Factory method to create a class to wrap a new ExperimentalFunctionBufferingResourceGetNext operation to the graph.
|
static IteratorGetNextSync |
IteratorGetNextSync.create(Scope scope,
Operand<?> iterator,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new IteratorGetNextSync operation to the graph.
|
static IteratorGetNext |
IteratorGetNext.create(Scope scope,
Operand<?> iterator,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new IteratorGetNext operation to the graph.
|
static UnbatchDataset |
UnbatchDataset.create(Scope scope,
Operand<?> inputDataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new UnbatchDataset operation to the graph.
|
static OptionalGetValue |
OptionalGetValue.create(Scope scope,
Operand<?> optional,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new OptionalGetValue operation to the graph.
|
static ExperimentalUniqueDataset |
ExperimentalUniqueDataset.create(Scope scope,
Operand<?> inputDataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalUniqueDataset operation to the graph.
|
static FilterByLastComponentDataset |
FilterByLastComponentDataset.create(Scope scope,
Operand<?> inputDataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new FilterByLastComponentDataset operation to the graph.
|
static DatasetToSingleElement |
DatasetToSingleElement.create(Scope scope,
Operand<?> dataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new DatasetToSingleElement operation to the graph.
|
static ModelDataset |
ModelDataset.create(Scope scope,
Operand<?> inputDataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ModelDataset operation to the graph.
|
static ExperimentalIgnoreErrorsDataset |
ExperimentalIgnoreErrorsDataset.create(Scope scope,
Operand<?> inputDataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalIgnoreErrorsDataset operation to the graph.
|
static IteratorGetNextAsOptional |
IteratorGetNextAsOptional.create(Scope scope,
Operand<?> iterator,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new IteratorGetNextAsOptional operation to the graph.
|
static QueueDequeue |
QueueDequeue.create(Scope scope,
Operand<?> handle,
List<Class<?>> componentTypes,
QueueDequeue.Options... options)
Factory method to create a class to wrap a new QueueDequeue operation to the graph.
|
static BoostedTreesQuantileStreamResourceGetBucketBoundaries |
BoostedTreesQuantileStreamResourceGetBucketBoundaries.create(Scope scope,
Operand<?> quantileStreamResourceHandle,
Long numFeatures)
Factory method to create a class to wrap a new BoostedTreesQuantileStreamResourceGetBucketBoundaries operation to the graph.
|
static <T extends Number> |
ResourceCountUpTo.create(Scope scope,
Operand<?> resource,
Long limit,
Class<T> T)
Factory method to create a class to wrap a new ResourceCountUpTo operation to the graph.
|
static DeserializeIterator |
DeserializeIterator.create(Scope scope,
Operand<?> resourceHandle,
Operand<?> serialized)
Factory method to create a class to wrap a new DeserializeIterator operation to the graph.
|
static MakeIterator |
MakeIterator.create(Scope scope,
Operand<?> dataset,
Operand<?> iterator)
Factory method to create a class to wrap a new MakeIterator operation to the graph.
|
static ReaderRead |
ReaderRead.create(Scope scope,
Operand<?> readerHandle,
Operand<?> queueHandle)
Factory method to create a class to wrap a new ReaderRead operation to the graph.
|
static ExperimentalIndexedDatasetMaterialize |
ExperimentalIndexedDatasetMaterialize.create(Scope scope,
Operand<?> dataset,
Operand<?> materialized)
Factory method to create a class to wrap a new ExperimentalIndexedDatasetMaterialize operation to the graph.
|
static <T> TensorListConcatLists |
TensorListConcatLists.create(Scope scope,
Operand<?> inputA,
Operand<?> inputB,
Class<T> elementDtype)
Factory method to create a class to wrap a new TensorListConcatLists operation to the graph.
|
static ExperimentalIndexedDatasetGet |
ExperimentalIndexedDatasetGet.create(Scope scope,
Operand<?> materialized,
Operand<?> index,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalIndexedDatasetGet operation to the graph.
|
static ExperimentalThreadPoolDataset |
ExperimentalThreadPoolDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<?> threadPool,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalThreadPoolDataset operation to the graph.
|
static ConcatenateDataset |
ConcatenateDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<?> anotherDataset,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ConcatenateDataset operation to the graph.
|
static SetStatsAggregatorDataset |
SetStatsAggregatorDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<?> statsAggregator,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new SetStatsAggregatorDataset operation to the graph.
|
static GcsConfigureBlockCache |
GcsConfigureBlockCache.create(Scope scope,
Operand<?> maxCacheSize,
Operand<?> blockSize,
Operand<?> maxStaleness)
Factory method to create a class to wrap a new GcsConfigureBlockCache operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyCenteredRMSProp.create(Scope scope,
Operand<?> var,
Operand<?> mg,
Operand<?> ms,
Operand<?> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
Operand<U> indices,
ResourceSparseApplyCenteredRMSProp.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyCenteredRMSProp operation to the graph.
|
static <T> ResourceApplyCenteredRMSProp |
ResourceApplyCenteredRMSProp.create(Scope scope,
Operand<?> var,
Operand<?> mg,
Operand<?> ms,
Operand<?> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
ResourceApplyCenteredRMSProp.Options... options)
Factory method to create a class to wrap a new ResourceApplyCenteredRMSProp operation to the graph.
|
static <T> ResourceApplyAdagradDA |
ResourceApplyAdagradDA.create(Scope scope,
Operand<?> var,
Operand<?> gradientAccumulator,
Operand<?> gradientSquaredAccumulator,
Operand<T> grad,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<Long> globalStep,
ResourceApplyAdagradDA.Options... options)
Factory method to create a class to wrap a new ResourceApplyAdagradDA operation to the graph.
|
static <T> ResourceApplyAdam |
ResourceApplyAdam.create(Scope scope,
Operand<?> var,
Operand<?> m,
Operand<?> v,
Operand<T> beta1Power,
Operand<T> beta2Power,
Operand<T> lr,
Operand<T> beta1,
Operand<T> beta2,
Operand<T> epsilon,
Operand<T> grad,
ResourceApplyAdam.Options... options)
Factory method to create a class to wrap a new ResourceApplyAdam operation to the graph.
|
static <T> ResourceApplyAdaMax |
ResourceApplyAdaMax.create(Scope scope,
Operand<?> var,
Operand<?> m,
Operand<?> v,
Operand<T> beta1Power,
Operand<T> lr,
Operand<T> beta1,
Operand<T> beta2,
Operand<T> epsilon,
Operand<T> grad,
ResourceApplyAdaMax.Options... options)
Factory method to create a class to wrap a new ResourceApplyAdaMax operation to the graph.
|
static <T> ResourceApplyFtrlV2 |
ResourceApplyFtrlV2.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<?> linear,
Operand<T> grad,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> l2Shrinkage,
Operand<T> lrPower,
ResourceApplyFtrlV2.Options... options)
Factory method to create a class to wrap a new ResourceApplyFtrlV2 operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyRMSProp.create(Scope scope,
Operand<?> var,
Operand<?> ms,
Operand<?> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
Operand<U> indices,
ResourceSparseApplyRMSProp.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyRMSProp operation to the graph.
|
static <T> ResourceApplyFtrl |
ResourceApplyFtrl.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<?> linear,
Operand<T> grad,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> lrPower,
ResourceApplyFtrl.Options... options)
Factory method to create a class to wrap a new ResourceApplyFtrl operation to the graph.
|
static <T> ResourceApplyRMSProp |
ResourceApplyRMSProp.create(Scope scope,
Operand<?> var,
Operand<?> ms,
Operand<?> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
ResourceApplyRMSProp.Options... options)
Factory method to create a class to wrap a new ResourceApplyRMSProp operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyAdadelta.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<?> accumUpdate,
Operand<T> lr,
Operand<T> rho,
Operand<T> epsilon,
Operand<T> grad,
Operand<U> indices,
ResourceSparseApplyAdadelta.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyAdadelta operation to the graph.
|
static <T> ResourceApplyAdadelta |
ResourceApplyAdadelta.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<?> accumUpdate,
Operand<T> lr,
Operand<T> rho,
Operand<T> epsilon,
Operand<T> grad,
ResourceApplyAdadelta.Options... options)
Factory method to create a class to wrap a new ResourceApplyAdadelta operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyAdagradDA.create(Scope scope,
Operand<?> var,
Operand<?> gradientAccumulator,
Operand<?> gradientSquaredAccumulator,
Operand<T> grad,
Operand<U> indices,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<Long> globalStep,
ResourceSparseApplyAdagradDA.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyAdagradDA operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyFtrlV2.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<?> linear,
Operand<T> grad,
Operand<U> indices,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> l2Shrinkage,
Operand<T> lrPower,
ResourceSparseApplyFtrlV2.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyFtrlV2 operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyFtrl.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<?> linear,
Operand<T> grad,
Operand<U> indices,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> lrPower,
ResourceSparseApplyFtrl.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyFtrl operation to the graph.
|
static MultiDeviceIteratorInit |
MultiDeviceIteratorInit.create(Scope scope,
Operand<?> dataset,
Operand<?> multiDeviceIterator,
Operand<Long> maxBufferSize)
Factory method to create a class to wrap a new MultiDeviceIteratorInit operation to the graph.
|
static ReaderReadUpTo |
ReaderReadUpTo.create(Scope scope,
Operand<?> readerHandle,
Operand<?> queueHandle,
Operand<Long> numRecords)
Factory method to create a class to wrap a new ReaderReadUpTo operation to the graph.
|
static <T> ResourceApplyAddSign |
ResourceApplyAddSign.create(Scope scope,
Operand<?> var,
Operand<?> m,
Operand<T> lr,
Operand<T> alpha,
Operand<T> signDecay,
Operand<T> beta,
Operand<T> grad,
ResourceApplyAddSign.Options... options)
Factory method to create a class to wrap a new ResourceApplyAddSign operation to the graph.
|
static <T> ResourceApplyPowerSign |
ResourceApplyPowerSign.create(Scope scope,
Operand<?> var,
Operand<?> m,
Operand<T> lr,
Operand<T> logbase,
Operand<T> signDecay,
Operand<T> beta,
Operand<T> grad,
ResourceApplyPowerSign.Options... options)
Factory method to create a class to wrap a new ResourceApplyPowerSign operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyProximalAdagrad.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> grad,
Operand<U> indices,
ResourceSparseApplyProximalAdagrad.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyProximalAdagrad operation to the graph.
|
static <T> ResourceApplyProximalAdagrad |
ResourceApplyProximalAdagrad.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> grad,
ResourceApplyProximalAdagrad.Options... options)
Factory method to create a class to wrap a new ResourceApplyProximalAdagrad operation to the graph.
|
static <T> ResourceApplyMomentum |
ResourceApplyMomentum.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<T> lr,
Operand<T> grad,
Operand<T> momentum,
ResourceApplyMomentum.Options... options)
Factory method to create a class to wrap a new ResourceApplyMomentum operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyMomentum.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<T> lr,
Operand<T> grad,
Operand<U> indices,
Operand<T> momentum,
ResourceSparseApplyMomentum.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyMomentum operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyAdagrad.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<T> lr,
Operand<T> grad,
Operand<U> indices,
ResourceSparseApplyAdagrad.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyAdagrad operation to the graph.
|
static <T> ResourceApplyAdagrad |
ResourceApplyAdagrad.create(Scope scope,
Operand<?> var,
Operand<?> accum,
Operand<T> lr,
Operand<T> grad,
ResourceApplyAdagrad.Options... options)
Factory method to create a class to wrap a new ResourceApplyAdagrad operation to the graph.
|
static TensorArraySize |
TensorArraySize.create(Scope scope,
Operand<?> handle,
Operand<Float> flowIn)
Factory method to create a class to wrap a new TensorArraySize operation to the graph.
|
static <T> TensorArrayConcat<T> |
TensorArrayConcat.create(Scope scope,
Operand<?> handle,
Operand<Float> flowIn,
Class<T> dtype,
TensorArrayConcat.Options... options)
Factory method to create a class to wrap a new TensorArrayConcat operation to the graph.
|
static BoostedTreesCenterBias |
BoostedTreesCenterBias.create(Scope scope,
Operand<?> treeEnsembleHandle,
Operand<Float> meanGradients,
Operand<Float> meanHessians,
Operand<Float> l1,
Operand<Float> l2)
Factory method to create a class to wrap a new BoostedTreesCenterBias operation to the graph.
|
static TensorArrayGradWithShape |
TensorArrayGradWithShape.create(Scope scope,
Operand<?> handle,
Operand<Float> flowIn,
Operand<Integer> shapeToPrepend,
String source)
Factory method to create a class to wrap a new TensorArrayGradWithShape operation to the graph.
|
static BoostedTreesCreateQuantileStreamResource |
BoostedTreesCreateQuantileStreamResource.create(Scope scope,
Operand<?> quantileStreamResourceHandle,
Operand<Float> epsilon,
Operand<Long> numStreams,
BoostedTreesCreateQuantileStreamResource.Options... options)
Factory method to create a class to wrap a new BoostedTreesCreateQuantileStreamResource operation to the graph.
|
static TensorArrayGrad |
TensorArrayGrad.create(Scope scope,
Operand<?> handle,
Operand<Float> flowIn,
String source)
Factory method to create a class to wrap a new TensorArrayGrad operation to the graph.
|
static IRFFT3D |
IRFFT3D.create(Scope scope,
Operand<?> input,
Operand<Integer> fftLength)
Factory method to create a class to wrap a new IRFFT3D operation to the graph.
|
static IRFFT |
IRFFT.create(Scope scope,
Operand<?> input,
Operand<Integer> fftLength)
Factory method to create a class to wrap a new IRFFT operation to the graph.
|
static IRFFT2D |
IRFFT2D.create(Scope scope,
Operand<?> input,
Operand<Integer> fftLength)
Factory method to create a class to wrap a new IRFFT2D operation to the graph.
|
static <T> TensorListGetItem<T> |
TensorListGetItem.create(Scope scope,
Operand<?> inputHandle,
Operand<Integer> index,
Class<T> elementDtype)
Factory method to create a class to wrap a new TensorListGetItem operation to the graph.
|
static <T> TensorListGather<T> |
TensorListGather.create(Scope scope,
Operand<?> inputHandle,
Operand<Integer> indices,
Class<T> elementDtype)
Factory method to create a class to wrap a new TensorListGather operation to the graph.
|
static BoostedTreesUpdateEnsemble |
BoostedTreesUpdateEnsemble.create(Scope scope,
Operand<?> treeEnsembleHandle,
Operand<Integer> featureIds,
Iterable<Operand<Integer>> nodeIds,
Iterable<Operand<Float>> gains,
Iterable<Operand<Integer>> thresholds,
Iterable<Operand<Float>> leftNodeContribs,
Iterable<Operand<Float>> rightNodeContribs,
Operand<Integer> maxDepth,
Operand<Float> learningRate,
Long pruningMode)
Factory method to create a class to wrap a new BoostedTreesUpdateEnsemble operation to the graph.
|
static QueueDequeueMany |
QueueDequeueMany.create(Scope scope,
Operand<?> handle,
Operand<Integer> n,
List<Class<?>> componentTypes,
QueueDequeueMany.Options... options)
Factory method to create a class to wrap a new QueueDequeueMany operation to the graph.
|
static QueueDequeueUpTo |
QueueDequeueUpTo.create(Scope scope,
Operand<?> handle,
Operand<Integer> n,
List<Class<?>> componentTypes,
QueueDequeueUpTo.Options... options)
Factory method to create a class to wrap a new QueueDequeueUpTo operation to the graph.
|
static <T> TensorArrayRead<T> |
TensorArrayRead.create(Scope scope,
Operand<?> handle,
Operand<Integer> index,
Operand<Float> flowIn,
Class<T> dtype)
Factory method to create a class to wrap a new TensorArrayRead operation to the graph.
|
static <T> TensorArrayGather<T> |
TensorArrayGather.create(Scope scope,
Operand<?> handle,
Operand<Integer> indices,
Operand<Float> flowIn,
Class<T> dtype,
TensorArrayGather.Options... options)
Factory method to create a class to wrap a new TensorArrayGather operation to the graph.
|
static BoostedTreesTrainingPredict |
BoostedTreesTrainingPredict.create(Scope scope,
Operand<?> treeEnsembleHandle,
Operand<Integer> cachedTreeIds,
Operand<Integer> cachedNodeIds,
Iterable<Operand<Integer>> bucketizedFeatures,
Long logitsDimension)
Factory method to create a class to wrap a new BoostedTreesTrainingPredict operation to the graph.
|
static MultiDeviceIteratorGetNextFromShard |
MultiDeviceIteratorGetNextFromShard.create(Scope scope,
Operand<?> multiDeviceIterator,
Operand<Integer> shardNum,
Operand<Long> incarnationId,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new MultiDeviceIteratorGetNextFromShard operation to the graph.
|
static <T> TensorListSetItem |
TensorListSetItem.create(Scope scope,
Operand<?> inputHandle,
Operand<Integer> index,
Operand<T> item)
Factory method to create a class to wrap a new TensorListSetItem operation to the graph.
|
static <T> TensorArrayWrite |
TensorArrayWrite.create(Scope scope,
Operand<?> handle,
Operand<Integer> index,
Operand<T> value,
Operand<Float> flowIn)
Factory method to create a class to wrap a new TensorArrayWrite operation to the graph.
|
static <T> TensorArrayScatter |
TensorArrayScatter.create(Scope scope,
Operand<?> handle,
Operand<Integer> indices,
Operand<T> value,
Operand<Float> flowIn)
Factory method to create a class to wrap a new TensorArrayScatter operation to the graph.
|
static BoostedTreesQuantileStreamResourceFlush |
BoostedTreesQuantileStreamResourceFlush.create(Scope scope,
Operand<?> quantileStreamResourceHandle,
Operand<Long> numBuckets,
BoostedTreesQuantileStreamResourceFlush.Options... options)
Factory method to create a class to wrap a new BoostedTreesQuantileStreamResourceFlush operation to the graph.
|
static ParseExampleDataset |
ParseExampleDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> numParallelCalls,
Iterable<Operand<?>> denseDefaults,
List<String> sparseKeys,
List<String> denseKeys,
List<Class<?>> sparseTypes,
List<Shape> denseShapes,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ParseExampleDataset operation to the graph.
|
static PaddedBatchDataset |
PaddedBatchDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> batchSize,
Iterable<Operand<Long>> paddedShapes,
Iterable<Operand<?>> paddingValues,
List<Shape> outputShapes)
Factory method to create a class to wrap a new PaddedBatchDataset operation to the graph.
|
static PrependFromQueueAndPaddedBatchDataset |
PrependFromQueueAndPaddedBatchDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> batchSize,
Iterable<Operand<Long>> paddedShapes,
Iterable<Operand<?>> paddingValues,
List<Shape> outputShapes)
Factory method to create a class to wrap a new PrependFromQueueAndPaddedBatchDataset operation to the graph.
|
static PaddedBatchDatasetV2 |
PaddedBatchDatasetV2.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> batchSize,
Iterable<Operand<Long>> paddedShapes,
Iterable<Operand<?>> paddingValues,
Operand<Boolean> dropRemainder,
List<Shape> outputShapes)
Factory method to create a class to wrap a new PaddedBatchDatasetV2 operation to the graph.
|
static PrefetchDataset |
PrefetchDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> bufferSize,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new PrefetchDataset operation to the graph.
|
static RepeatDataset |
RepeatDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> count,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new RepeatDataset operation to the graph.
|
static BatchDataset |
BatchDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> batchSize,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new BatchDataset operation to the graph.
|
static TakeDataset |
TakeDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> count,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new TakeDataset operation to the graph.
|
static SkipDataset |
SkipDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> count,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new SkipDataset operation to the graph.
|
static BatchDatasetV2 |
BatchDatasetV2.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> batchSize,
Operand<Boolean> dropRemainder,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new BatchDatasetV2 operation to the graph.
|
static DenseToSparseBatchDataset |
DenseToSparseBatchDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> batchSize,
Operand<Long> rowShape,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new DenseToSparseBatchDataset operation to the graph.
|
static SlideDataset |
SlideDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> windowSize,
Operand<Long> windowShift,
Operand<Long> windowStride,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new SlideDataset operation to the graph.
|
static ShuffleDataset |
ShuffleDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> bufferSize,
Operand<Long> seed,
Operand<Long> seed2,
List<Class<?>> outputTypes,
List<Shape> outputShapes,
ShuffleDataset.Options... options)
Factory method to create a class to wrap a new ShuffleDataset operation to the graph.
|
static WindowDataset |
WindowDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> size,
Operand<Long> shift,
Operand<Long> stride,
Operand<Boolean> dropRemainder,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new WindowDataset operation to the graph.
|
static ShuffleAndRepeatDataset |
ShuffleAndRepeatDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<Long> bufferSize,
Operand<Long> seed,
Operand<Long> seed2,
Operand<Long> count,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ShuffleAndRepeatDataset operation to the graph.
|
static BoostedTreesCreateEnsemble |
BoostedTreesCreateEnsemble.create(Scope scope,
Operand<?> treeEnsembleHandle,
Operand<Long> stampToken,
Operand<String> treeEnsembleSerialized)
Factory method to create a class to wrap a new BoostedTreesCreateEnsemble operation to the graph.
|
static WriteGraphSummary |
WriteGraphSummary.create(Scope scope,
Operand<?> writer,
Operand<Long> step,
Operand<String> tensor)
Factory method to create a class to wrap a new WriteGraphSummary operation to the graph.
|
static BoostedTreesDeserializeEnsemble |
BoostedTreesDeserializeEnsemble.create(Scope scope,
Operand<?> treeEnsembleHandle,
Operand<Long> stampToken,
Operand<String> treeEnsembleSerialized)
Factory method to create a class to wrap a new BoostedTreesDeserializeEnsemble operation to the graph.
|
static WriteAudioSummary |
WriteAudioSummary.create(Scope scope,
Operand<?> writer,
Operand<Long> step,
Operand<String> tag,
Operand<Float> tensor,
Operand<Float> sampleRate,
WriteAudioSummary.Options... options)
Factory method to create a class to wrap a new WriteAudioSummary operation to the graph.
|
static <T extends Number> |
WriteScalarSummary.create(Scope scope,
Operand<?> writer,
Operand<Long> step,
Operand<String> tag,
Operand<T> value)
Factory method to create a class to wrap a new WriteScalarSummary operation to the graph.
|
static <T extends Number> |
WriteHistogramSummary.create(Scope scope,
Operand<?> writer,
Operand<Long> step,
Operand<String> tag,
Operand<T> values)
Factory method to create a class to wrap a new WriteHistogramSummary operation to the graph.
|
static <T extends Number> |
WriteImageSummary.create(Scope scope,
Operand<?> writer,
Operand<Long> step,
Operand<String> tag,
Operand<T> tensor,
Operand<UInt8> badColor,
WriteImageSummary.Options... options)
Factory method to create a class to wrap a new WriteImageSummary operation to the graph.
|
static <T> WriteSummary |
WriteSummary.create(Scope scope,
Operand<?> writer,
Operand<Long> step,
Operand<T> tensor,
Operand<String> tag,
Operand<String> summaryMetadata)
Factory method to create a class to wrap a new WriteSummary operation to the graph.
|
static ImportEvent |
ImportEvent.create(Scope scope,
Operand<?> writer,
Operand<String> event)
Factory method to create a class to wrap a new ImportEvent operation to the graph.
|
static ReaderRestoreState |
ReaderRestoreState.create(Scope scope,
Operand<?> readerHandle,
Operand<String> state)
Factory method to create a class to wrap a new ReaderRestoreState operation to the graph.
|
static LatencyStatsDataset |
LatencyStatsDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<String> tag,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new LatencyStatsDataset operation to the graph.
|
static OptimizeDataset |
OptimizeDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<String> optimizations,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new OptimizeDataset operation to the graph.
|
static ExperimentalAssertNextDataset |
ExperimentalAssertNextDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<String> transformations,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalAssertNextDataset operation to the graph.
|
static BytesProducedStatsDataset |
BytesProducedStatsDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<String> tag,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new BytesProducedStatsDataset operation to the graph.
|
static CacheDataset |
CacheDataset.create(Scope scope,
Operand<?> inputDataset,
Operand<String> filename,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new CacheDataset operation to the graph.
|
static InitializeTableFromTextFile |
InitializeTableFromTextFile.create(Scope scope,
Operand<?> tableHandle,
Operand<String> filename,
Long keyIndex,
Long valueIndex,
InitializeTableFromTextFile.Options... options)
Factory method to create a class to wrap a new InitializeTableFromTextFile operation to the graph.
|
static CreateSummaryFileWriter |
CreateSummaryFileWriter.create(Scope scope,
Operand<?> writer,
Operand<String> logdir,
Operand<Integer> maxQueue,
Operand<Integer> flushMillis,
Operand<String> filenameSuffix)
Factory method to create a class to wrap a new CreateSummaryFileWriter operation to the graph.
|
static DatasetToTFRecord |
DatasetToTFRecord.create(Scope scope,
Operand<?> inputDataset,
Operand<String> filename,
Operand<String> compressionType)
Factory method to create a class to wrap a new DatasetToTFRecord operation to the graph.
|
static CreateSummaryDbWriter |
CreateSummaryDbWriter.create(Scope scope,
Operand<?> writer,
Operand<String> dbUri,
Operand<String> experimentName,
Operand<String> runName,
Operand<String> userName)
Factory method to create a class to wrap a new CreateSummaryDbWriter operation to the graph.
|
static <T> TensorListPushBackBatch |
TensorListPushBackBatch.create(Scope scope,
Operand<?> inputHandles,
Operand<T> tensor)
Factory method to create a class to wrap a new TensorListPushBackBatch operation to the graph.
|
static <T> AssignSubVariableOp |
AssignSubVariableOp.create(Scope scope,
Operand<?> resource,
Operand<T> value)
Factory method to create a class to wrap a new AssignSubVariableOp operation to the graph.
|
static <T> TensorListPushBack |
TensorListPushBack.create(Scope scope,
Operand<?> inputHandle,
Operand<T> tensor)
Factory method to create a class to wrap a new TensorListPushBack operation to the graph.
|
static <T> AssignVariableOp |
AssignVariableOp.create(Scope scope,
Operand<?> resource,
Operand<T> value)
Factory method to create a class to wrap a new AssignVariableOp operation to the graph.
|
static <T> AssignAddVariableOp |
AssignAddVariableOp.create(Scope scope,
Operand<?> resource,
Operand<T> value)
Factory method to create a class to wrap a new AssignAddVariableOp operation to the graph.
|
static <U,T extends Number> |
ResourceGather.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Class<U> dtype,
ResourceGather.Options... options)
Factory method to create a class to wrap a new ResourceGather operation to the graph.
|
static <T> TensorArraySplit |
TensorArraySplit.create(Scope scope,
Operand<?> handle,
Operand<T> value,
Operand<Long> lengths,
Operand<Float> flowIn)
Factory method to create a class to wrap a new TensorArraySplit operation to the graph.
|
static <T,U extends Number> |
ResourceSparseApplyProximalGradientDescent.create(Scope scope,
Operand<?> var,
Operand<T> alpha,
Operand<T> l1,
Operand<T> l2,
Operand<T> grad,
Operand<U> indices,
ResourceSparseApplyProximalGradientDescent.Options... options)
Factory method to create a class to wrap a new ResourceSparseApplyProximalGradientDescent operation to the graph.
|
static <T> ResourceApplyProximalGradientDescent |
ResourceApplyProximalGradientDescent.create(Scope scope,
Operand<?> var,
Operand<T> alpha,
Operand<T> l1,
Operand<T> l2,
Operand<T> delta,
ResourceApplyProximalGradientDescent.Options... options)
Factory method to create a class to wrap a new ResourceApplyProximalGradientDescent operation to the graph.
|
static <T extends Number,U> |
ResourceStridedSliceAssign.create(Scope scope,
Operand<?> ref,
Operand<T> begin,
Operand<T> end,
Operand<T> strides,
Operand<U> value,
ResourceStridedSliceAssign.Options... options)
Factory method to create a class to wrap a new ResourceStridedSliceAssign operation to the graph.
|
static <T> ResourceApplyGradientDescent |
ResourceApplyGradientDescent.create(Scope scope,
Operand<?> var,
Operand<T> alpha,
Operand<T> delta,
ResourceApplyGradientDescent.Options... options)
Factory method to create a class to wrap a new ResourceApplyGradientDescent operation to the graph.
|
static <T extends Number,U> |
ResourceScatterMax.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterMax operation to the graph.
|
static <T extends Number,U> |
ResourceScatterDiv.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterDiv operation to the graph.
|
static <T extends Number,U> |
ResourceScatterSub.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterSub operation to the graph.
|
static <T extends Number,U> |
ResourceScatterMul.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterMul operation to the graph.
|
static <T extends Number,U> |
ResourceScatterUpdate.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterUpdate operation to the graph.
|
static <T extends Number,U> |
ResourceScatterMin.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterMin operation to the graph.
|
static <T extends Number,U> |
ResourceScatterAdd.create(Scope scope,
Operand<?> resource,
Operand<T> indices,
Operand<U> updates)
Factory method to create a class to wrap a new ResourceScatterAdd operation to the graph.
|
static <T,U> LookupTableImport |
LookupTableImport.create(Scope scope,
Operand<?> tableHandle,
Operand<T> keys,
Operand<U> values)
Factory method to create a class to wrap a new LookupTableImport operation to the graph.
|
static <T,U> InitializeTable |
InitializeTable.create(Scope scope,
Operand<?> tableHandle,
Operand<T> keys,
Operand<U> values)
Factory method to create a class to wrap a new InitializeTable operation to the graph.
|
static <T,U> LookupTableInsert |
LookupTableInsert.create(Scope scope,
Operand<?> tableHandle,
Operand<T> keys,
Operand<U> values)
Factory method to create a class to wrap a new LookupTableInsert operation to the graph.
|
static <U,T> LookupTableFind<U> |
LookupTableFind.create(Scope scope,
Operand<?> tableHandle,
Operand<T> keys,
Operand<U> defaultValue)
Factory method to create a class to wrap a new LookupTableFind operation to the graph.
|
static <T extends Number,U> |
ResourceScatterNdAdd.create(Scope scope,
Operand<?> ref,
Operand<T> indices,
Operand<U> updates,
ResourceScatterNdAdd.Options... options)
Factory method to create a class to wrap a new ResourceScatterNdAdd operation to the graph.
|
static <T extends Number,U> |
ResourceScatterNdUpdate.create(Scope scope,
Operand<?> ref,
Operand<T> indices,
Operand<U> updates,
ResourceScatterNdUpdate.Options... options)
Factory method to create a class to wrap a new ResourceScatterNdUpdate operation to the graph.
|
static QueueClose |
QueueClose.create(Scope scope,
Operand<?> handle,
QueueClose.Options... options)
Factory method to create a class to wrap a new QueueClose operation to the graph.
|
static LogicalNot |
LogicalNot.create(Scope scope,
Operand<Boolean> x)
Factory method to create a class to wrap a new LogicalNot operation to the graph.
|
static LoopCond |
LoopCond.create(Scope scope,
Operand<Boolean> input)
Factory method to create a class to wrap a new LoopCond operation to the graph.
|
static Assert |
Assert.create(Scope scope,
Operand<Boolean> condition,
Iterable<Operand<?>> data,
Assert.Options... options)
Factory method to create a class to wrap a new Assert operation to the graph.
|
static LogicalAnd |
LogicalAnd.create(Scope scope,
Operand<Boolean> x,
Operand<Boolean> y)
Factory method to create a class to wrap a new LogicalAnd operation to the graph.
|
static LogicalOr |
LogicalOr.create(Scope scope,
Operand<Boolean> x,
Operand<Boolean> y)
Factory method to create a class to wrap a new LogicalOr operation to the graph.
|
static <T extends Number> |
All.create(Scope scope,
Operand<Boolean> input,
Operand<T> axis,
All.Options... options)
Factory method to create a class to wrap a new All operation to the graph.
|
static <T extends Number> |
Any.create(Scope scope,
Operand<Boolean> input,
Operand<T> axis,
Any.Options... options)
Factory method to create a class to wrap a new Any operation to the graph.
|
static <T> Where3<T> |
Where3.create(Scope scope,
Operand<Boolean> condition,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Where3 operation to the graph.
|
static <T extends Number> |
ReduceAll.create(Scope scope,
Operand<Boolean> input,
Operand<T> axis,
ReduceAll.Options... options)
Factory method to create a class to wrap a new ReduceAll operation to the graph.
|
static <T extends Number> |
ReduceAny.create(Scope scope,
Operand<Boolean> input,
Operand<T> axis,
ReduceAny.Options... options)
Factory method to create a class to wrap a new ReduceAny operation to the graph.
|
static FakeQuantWithMinMaxArgs |
FakeQuantWithMinMaxArgs.create(Scope scope,
Operand<Float> inputs,
FakeQuantWithMinMaxArgs.Options... options)
Factory method to create a class to wrap a new FakeQuantWithMinMaxArgs operation to the graph.
|
static AudioSpectrogram |
AudioSpectrogram.create(Scope scope,
Operand<Float> input,
Long windowSize,
Long stride,
AudioSpectrogram.Options... options)
Factory method to create a class to wrap a new AudioSpectrogram operation to the graph.
|
static AdjustSaturation |
AdjustSaturation.create(Scope scope,
Operand<Float> images,
Operand<Float> scale)
Factory method to create a class to wrap a new AdjustSaturation operation to the graph.
|
static AdjustHue |
AdjustHue.create(Scope scope,
Operand<Float> images,
Operand<Float> delta)
Factory method to create a class to wrap a new AdjustHue operation to the graph.
|
static AdjustContrast |
AdjustContrast.create(Scope scope,
Operand<Float> images,
Operand<Float> contrastFactor)
Factory method to create a class to wrap a new AdjustContrast operation to the graph.
|
static FakeQuantWithMinMaxArgsGradient |
FakeQuantWithMinMaxArgsGradient.create(Scope scope,
Operand<Float> gradients,
Operand<Float> inputs,
FakeQuantWithMinMaxArgsGradient.Options... options)
Factory method to create a class to wrap a new FakeQuantWithMinMaxArgsGradient operation to the graph.
|
static <T> QuantizeV2<T> |
QuantizeV2.create(Scope scope,
Operand<Float> input,
Operand<Float> minRange,
Operand<Float> maxRange,
Class<T> T,
QuantizeV2.Options... options)
Factory method to create a class to wrap a new QuantizeV2 operation to the graph.
|
static FakeQuantWithMinMaxVars |
FakeQuantWithMinMaxVars.create(Scope scope,
Operand<Float> inputs,
Operand<Float> min,
Operand<Float> max,
FakeQuantWithMinMaxVars.Options... options)
Factory method to create a class to wrap a new FakeQuantWithMinMaxVars operation to the graph.
|
static FakeQuantWithMinMaxVarsPerChannel |
FakeQuantWithMinMaxVarsPerChannel.create(Scope scope,
Operand<Float> inputs,
Operand<Float> min,
Operand<Float> max,
FakeQuantWithMinMaxVarsPerChannel.Options... options)
Factory method to create a class to wrap a new FakeQuantWithMinMaxVarsPerChannel operation to the graph.
|
static FakeQuantWithMinMaxVarsGradient |
FakeQuantWithMinMaxVarsGradient.create(Scope scope,
Operand<Float> gradients,
Operand<Float> inputs,
Operand<Float> min,
Operand<Float> max,
FakeQuantWithMinMaxVarsGradient.Options... options)
Factory method to create a class to wrap a new FakeQuantWithMinMaxVarsGradient operation to the graph.
|
static FakeQuantWithMinMaxVarsPerChannelGradient |
FakeQuantWithMinMaxVarsPerChannelGradient.create(Scope scope,
Operand<Float> gradients,
Operand<Float> inputs,
Operand<Float> min,
Operand<Float> max,
FakeQuantWithMinMaxVarsPerChannelGradient.Options... options)
Factory method to create a class to wrap a new FakeQuantWithMinMaxVarsPerChannelGradient operation to the graph.
|
static NonMaxSuppression |
NonMaxSuppression.create(Scope scope,
Operand<Float> boxes,
Operand<Float> scores,
Operand<Integer> maxOutputSize,
NonMaxSuppression.Options... options)
Factory method to create a class to wrap a new NonMaxSuppression operation to the graph.
|
static NonMaxSuppressionWithOverlaps |
NonMaxSuppressionWithOverlaps.create(Scope scope,
Operand<Float> overlaps,
Operand<Float> scores,
Operand<Integer> maxOutputSize,
Operand<Float> overlapThreshold,
Operand<Float> scoreThreshold)
Factory method to create a class to wrap a new NonMaxSuppressionWithOverlaps operation to the graph.
|
static <T extends Number> |
CropAndResizeGradImage.create(Scope scope,
Operand<Float> grads,
Operand<Float> boxes,
Operand<Integer> boxInd,
Operand<Integer> imageSize,
Class<T> T,
CropAndResizeGradImage.Options... options)
Factory method to create a class to wrap a new CropAndResizeGradImage operation to the graph.
|
static NegTrain |
NegTrain.create(Scope scope,
Operand<Float> wIn,
Operand<Float> wOut,
Operand<Integer> examples,
Operand<Integer> labels,
Operand<Float> lr,
List<Long> vocabCount,
Long numNegativeSamples)
Factory method to create a class to wrap a new NegTrain operation to the graph.
|
static EncodeWav |
EncodeWav.create(Scope scope,
Operand<Float> audio,
Operand<Integer> sampleRate)
Factory method to create a class to wrap a new EncodeWav operation to the graph.
|
static RFFT2D |
RFFT2D.create(Scope scope,
Operand<Float> input,
Operand<Integer> fftLength)
Factory method to create a class to wrap a new RFFT2D operation to the graph.
|
static RFFT3D |
RFFT3D.create(Scope scope,
Operand<Float> input,
Operand<Integer> fftLength)
Factory method to create a class to wrap a new RFFT3D operation to the graph.
|
static RFFT |
RFFT.create(Scope scope,
Operand<Float> input,
Operand<Integer> fftLength)
Factory method to create a class to wrap a new RFFT operation to the graph.
|
static CTCGreedyDecoder |
CTCGreedyDecoder.create(Scope scope,
Operand<Float> inputs,
Operand<Integer> sequenceLength,
CTCGreedyDecoder.Options... options)
Factory method to create a class to wrap a new CTCGreedyDecoder operation to the graph.
|
static CTCBeamSearchDecoder |
CTCBeamSearchDecoder.create(Scope scope,
Operand<Float> inputs,
Operand<Integer> sequenceLength,
Long beamWidth,
Long topPaths,
CTCBeamSearchDecoder.Options... options)
Factory method to create a class to wrap a new CTCBeamSearchDecoder operation to the graph.
|
static Mfcc |
Mfcc.create(Scope scope,
Operand<Float> spectrogram,
Operand<Integer> sampleRate,
Mfcc.Options... options)
Factory method to create a class to wrap a new Mfcc operation to the graph.
|
static ExtractGlimpse |
ExtractGlimpse.create(Scope scope,
Operand<Float> input,
Operand<Integer> size,
Operand<Float> offsets,
ExtractGlimpse.Options... options)
Factory method to create a class to wrap a new ExtractGlimpse operation to the graph.
|
static CTCLoss |
CTCLoss.create(Scope scope,
Operand<Float> inputs,
Operand<Long> labelsIndices,
Operand<Integer> labelsValues,
Operand<Integer> sequenceLength,
CTCLoss.Options... options)
Factory method to create a class to wrap a new CTCLoss operation to the graph.
|
static <T extends Number> |
InTopK.create(Scope scope,
Operand<Float> predictions,
Operand<T> targets,
Long k)
Factory method to create a class to wrap a new InTopK operation to the graph.
|
static <T extends Number> |
CropAndResizeGradBoxes.create(Scope scope,
Operand<Float> grads,
Operand<T> image,
Operand<Float> boxes,
Operand<Integer> boxInd,
CropAndResizeGradBoxes.Options... options)
Factory method to create a class to wrap a new CropAndResizeGradBoxes operation to the graph.
|
static <T extends Number> |
InTopKV2.create(Scope scope,
Operand<Float> predictions,
Operand<T> targets,
Operand<T> k)
Factory method to create a class to wrap a new InTopKV2 operation to the graph.
|
static <T extends Number> |
ResizeBicubicGrad.create(Scope scope,
Operand<Float> grads,
Operand<T> originalImage,
ResizeBicubicGrad.Options... options)
Factory method to create a class to wrap a new ResizeBicubicGrad operation to the graph.
|
static <T extends Number> |
ResizeBilinearGrad.create(Scope scope,
Operand<Float> grads,
Operand<T> originalImage,
ResizeBilinearGrad.Options... options)
Factory method to create a class to wrap a new ResizeBilinearGrad operation to the graph.
|
static UnicodeScript |
UnicodeScript.create(Scope scope,
Operand<Integer> input)
Factory method to create a class to wrap a new UnicodeScript operation to the graph.
|
static <T> Empty<T> |
Empty.create(Scope scope,
Operand<Integer> shape,
Class<T> dtype,
Empty.Options... options)
Factory method to create a class to wrap a new Empty operation to the graph.
|
static <T> TensorArray |
TensorArray.create(Scope scope,
Operand<Integer> size,
Class<T> dtype,
TensorArray.Options... options)
Factory method to create a class to wrap a new TensorArray operation to the graph.
|
static EncodeProto |
EncodeProto.create(Scope scope,
Operand<Integer> sizes,
Iterable<Operand<?>> values,
List<String> fieldNames,
String messageType,
EncodeProto.Options... options)
Factory method to create a class to wrap a new EncodeProto operation to the graph.
|
static BoostedTreesCalculateBestGainsPerFeature |
BoostedTreesCalculateBestGainsPerFeature.create(Scope scope,
Operand<Integer> nodeIdRange,
Iterable<Operand<Float>> statsSummaryList,
Operand<Float> l1,
Operand<Float> l2,
Operand<Float> treeComplexity,
Operand<Float> minNodeWeight,
Long maxSplits)
Factory method to create a class to wrap a new BoostedTreesCalculateBestGainsPerFeature operation to the graph.
|
static MapUnstageNoKey |
MapUnstageNoKey.create(Scope scope,
Operand<Integer> indices,
List<Class<?>> dtypes,
MapUnstageNoKey.Options... options)
Factory method to create a class to wrap a new MapUnstageNoKey operation to the graph.
|
static OrderedMapUnstageNoKey |
OrderedMapUnstageNoKey.create(Scope scope,
Operand<Integer> indices,
List<Class<?>> dtypes,
OrderedMapUnstageNoKey.Options... options)
Factory method to create a class to wrap a new OrderedMapUnstageNoKey operation to the graph.
|
static StagePeek |
StagePeek.create(Scope scope,
Operand<Integer> index,
List<Class<?>> dtypes,
StagePeek.Options... options)
Factory method to create a class to wrap a new StagePeek operation to the graph.
|
static BoostedTreesMakeStatsSummary |
BoostedTreesMakeStatsSummary.create(Scope scope,
Operand<Integer> nodeIds,
Operand<Float> gradients,
Operand<Float> hessians,
Iterable<Operand<Integer>> bucketizedFeaturesList,
Long maxSplits,
Long numBuckets)
Factory method to create a class to wrap a new BoostedTreesMakeStatsSummary operation to the graph.
|
static <U extends Number,T extends Number> |
CudnnRNNParamsSize.create(Scope scope,
Operand<Integer> numLayers,
Operand<Integer> numUnits,
Operand<Integer> inputSize,
Class<T> T,
Class<U> S,
CudnnRNNParamsSize.Options... options)
Factory method to create a class to wrap a new CudnnRNNParamsSize operation to the graph.
|
static <T extends Number> |
CudnnRNNCanonicalToParams.create(Scope scope,
Operand<Integer> numLayers,
Operand<Integer> numUnits,
Operand<Integer> inputSize,
Operand<T> weights,
Iterable<Operand<T>> biases,
CudnnRNNCanonicalToParams.Options... options)
Factory method to create a class to wrap a new CudnnRNNCanonicalToParams operation to the graph.
|
static <T extends Number> |
CudnnRNNParamsToCanonical.create(Scope scope,
Operand<Integer> numLayers,
Operand<Integer> numUnits,
Operand<Integer> inputSize,
Operand<T> params,
Long numParams,
CudnnRNNParamsToCanonical.Options... options)
Factory method to create a class to wrap a new CudnnRNNParamsToCanonical operation to the graph.
|
static <T extends Number> |
Bincount.create(Scope scope,
Operand<Integer> arr,
Operand<Integer> size,
Operand<T> weights)
Factory method to create a class to wrap a new Bincount operation to the graph.
|
static <T> RefSelect<T> |
RefSelect.create(Scope scope,
Operand<Integer> index,
Operand<T> inputs)
Factory method to create a class to wrap a new RefSelect operation to the graph.
|
static <T> QuantizedConcat<T> |
QuantizedConcat.create(Scope scope,
Operand<Integer> concatDim,
Operand<T> values,
Iterable<Operand<Float>> inputMins,
Iterable<Operand<Float>> inputMaxes)
Factory method to create a class to wrap a new QuantizedConcat operation to the graph.
|
static <T extends Number> |
AvgPool3DGrad.create(Scope scope,
Operand<Integer> origInputShape,
Operand<T> grad,
List<Long> ksize,
List<Long> strides,
String padding,
AvgPool3DGrad.Options... options)
Factory method to create a class to wrap a new AvgPool3DGrad operation to the graph.
|
static <T extends Number> |
AvgPoolGrad.create(Scope scope,
Operand<Integer> origInputShape,
Operand<T> grad,
List<Long> ksize,
List<Long> strides,
String padding,
AvgPoolGrad.Options... options)
Factory method to create a class to wrap a new AvgPoolGrad operation to the graph.
|
static <T> Split<T> |
Split.create(Scope scope,
Operand<Integer> axis,
Operand<T> value,
Long numSplit)
Factory method to create a class to wrap a new Split operation to the graph.
|
static <T extends Number> |
Conv2DBackpropInput.create(Scope scope,
Operand<Integer> inputSizes,
Operand<T> filter,
Operand<T> outBackprop,
List<Long> strides,
String padding,
Conv2DBackpropInput.Options... options)
Factory method to create a class to wrap a new Conv2DBackpropInput operation to the graph.
|
static <T extends Number> |
DepthwiseConv2dNativeBackpropInput.create(Scope scope,
Operand<Integer> inputSizes,
Operand<T> filter,
Operand<T> outBackprop,
List<Long> strides,
String padding,
DepthwiseConv2dNativeBackpropInput.Options... options)
Factory method to create a class to wrap a new DepthwiseConv2dNativeBackpropInput operation to the graph.
|
static <T> TakeManySparseFromTensorsMap<T> |
TakeManySparseFromTensorsMap.create(Scope scope,
Operand<Long> sparseHandles,
Class<T> dtype,
TakeManySparseFromTensorsMap.Options... options)
Factory method to create a class to wrap a new TakeManySparseFromTensorsMap operation to the graph.
|
static AllCandidateSampler |
AllCandidateSampler.create(Scope scope,
Operand<Long> trueClasses,
Long numTrue,
Long numSampled,
Boolean unique,
AllCandidateSampler.Options... options)
Factory method to create a class to wrap a new AllCandidateSampler operation to the graph.
|
static FixedUnigramCandidateSampler |
FixedUnigramCandidateSampler.create(Scope scope,
Operand<Long> trueClasses,
Long numTrue,
Long numSampled,
Boolean unique,
Long rangeMax,
FixedUnigramCandidateSampler.Options... options)
Factory method to create a class to wrap a new FixedUnigramCandidateSampler operation to the graph.
|
static LearnedUnigramCandidateSampler |
LearnedUnigramCandidateSampler.create(Scope scope,
Operand<Long> trueClasses,
Long numTrue,
Long numSampled,
Boolean unique,
Long rangeMax,
LearnedUnigramCandidateSampler.Options... options)
Factory method to create a class to wrap a new LearnedUnigramCandidateSampler operation to the graph.
|
static LogUniformCandidateSampler |
LogUniformCandidateSampler.create(Scope scope,
Operand<Long> trueClasses,
Long numTrue,
Long numSampled,
Boolean unique,
Long rangeMax,
LogUniformCandidateSampler.Options... options)
Factory method to create a class to wrap a new LogUniformCandidateSampler operation to the graph.
|
static UniformCandidateSampler |
UniformCandidateSampler.create(Scope scope,
Operand<Long> trueClasses,
Long numTrue,
Long numSampled,
Boolean unique,
Long rangeMax,
UniformCandidateSampler.Options... options)
Factory method to create a class to wrap a new UniformCandidateSampler operation to the graph.
|
static MapStage |
MapStage.create(Scope scope,
Operand<Long> key,
Operand<Integer> indices,
Iterable<Operand<?>> values,
List<Class<?>> dtypes,
MapStage.Options... options)
Factory method to create a class to wrap a new MapStage operation to the graph.
|
static OrderedMapStage |
OrderedMapStage.create(Scope scope,
Operand<Long> key,
Operand<Integer> indices,
Iterable<Operand<?>> values,
List<Class<?>> dtypes,
OrderedMapStage.Options... options)
Factory method to create a class to wrap a new OrderedMapStage operation to the graph.
|
static MapPeek |
MapPeek.create(Scope scope,
Operand<Long> key,
Operand<Integer> indices,
List<Class<?>> dtypes,
MapPeek.Options... options)
Factory method to create a class to wrap a new MapPeek operation to the graph.
|
static MapUnstage |
MapUnstage.create(Scope scope,
Operand<Long> key,
Operand<Integer> indices,
List<Class<?>> dtypes,
MapUnstage.Options... options)
Factory method to create a class to wrap a new MapUnstage operation to the graph.
|
static OrderedMapPeek |
OrderedMapPeek.create(Scope scope,
Operand<Long> key,
Operand<Integer> indices,
List<Class<?>> dtypes,
OrderedMapPeek.Options... options)
Factory method to create a class to wrap a new OrderedMapPeek operation to the graph.
|
static OrderedMapUnstage |
OrderedMapUnstage.create(Scope scope,
Operand<Long> key,
Operand<Integer> indices,
List<Class<?>> dtypes,
OrderedMapUnstage.Options... options)
Factory method to create a class to wrap a new OrderedMapUnstage operation to the graph.
|
static RandomDataset |
RandomDataset.create(Scope scope,
Operand<Long> seed,
Operand<Long> seed2,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new RandomDataset operation to the graph.
|
static ComputeAccidentalHits |
ComputeAccidentalHits.create(Scope scope,
Operand<Long> trueClasses,
Operand<Long> sampledCandidates,
Long numTrue,
ComputeAccidentalHits.Options... options)
Factory method to create a class to wrap a new ComputeAccidentalHits operation to the graph.
|
static SparseReshape |
SparseReshape.create(Scope scope,
Operand<Long> inputIndices,
Operand<Long> inputShape,
Operand<Long> newShape)
Factory method to create a class to wrap a new SparseReshape operation to the graph.
|
static RangeDataset |
RangeDataset.create(Scope scope,
Operand<Long> start,
Operand<Long> stop,
Operand<Long> step,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new RangeDataset operation to the graph.
|
static <T> SparseSplit<T> |
SparseSplit.create(Scope scope,
Operand<Long> splitDim,
Operand<Long> indices,
Operand<T> values,
Operand<Long> shape,
Long numSplit)
Factory method to create a class to wrap a new SparseSplit operation to the graph.
|
static <T> SparseFillEmptyRowsGrad<T> |
SparseFillEmptyRowsGrad.create(Scope scope,
Operand<Long> reverseIndexMap,
Operand<T> gradValues)
Factory method to create a class to wrap a new SparseFillEmptyRowsGrad operation to the graph.
|
static <T> SparseTensorSliceDataset |
SparseTensorSliceDataset.create(Scope scope,
Operand<Long> indices,
Operand<T> values,
Operand<Long> denseShape)
Factory method to create a class to wrap a new SparseTensorSliceDataset operation to the graph.
|
static <T> SerializeManySparse<String> |
SerializeManySparse.create(Scope scope,
Operand<Long> sparseIndices,
Operand<T> sparseValues,
Operand<Long> sparseShape)
Factory method to create a class to wrap a new SerializeManySparse operation to the graph, using default output types.
|
static <T> SerializeSparse<String> |
SerializeSparse.create(Scope scope,
Operand<Long> sparseIndices,
Operand<T> sparseValues,
Operand<Long> sparseShape)
Factory method to create a class to wrap a new SerializeSparse operation to the graph, using default output types.
|
static <T> SparseReorder<T> |
SparseReorder.create(Scope scope,
Operand<Long> inputIndices,
Operand<T> inputValues,
Operand<Long> inputShape)
Factory method to create a class to wrap a new SparseReorder operation to the graph.
|
static <T extends Number> |
SparseSoftmax.create(Scope scope,
Operand<Long> spIndices,
Operand<T> spValues,
Operand<Long> spShape)
Factory method to create a class to wrap a new SparseSoftmax operation to the graph.
|
static <T> AddManySparseToTensorsMap |
AddManySparseToTensorsMap.create(Scope scope,
Operand<Long> sparseIndices,
Operand<T> sparseValues,
Operand<Long> sparseShape,
AddManySparseToTensorsMap.Options... options)
Factory method to create a class to wrap a new AddManySparseToTensorsMap operation to the graph.
|
static <T> AddSparseToTensorsMap |
AddSparseToTensorsMap.create(Scope scope,
Operand<Long> sparseIndices,
Operand<T> sparseValues,
Operand<Long> sparseShape,
AddSparseToTensorsMap.Options... options)
Factory method to create a class to wrap a new AddSparseToTensorsMap operation to the graph.
|
static <U,T> SerializeManySparse<U> |
SerializeManySparse.create(Scope scope,
Operand<Long> sparseIndices,
Operand<T> sparseValues,
Operand<Long> sparseShape,
Class<U> outType)
Factory method to create a class to wrap a new SerializeManySparse operation to the graph.
|
static <U,T> SerializeSparse<U> |
SerializeSparse.create(Scope scope,
Operand<Long> sparseIndices,
Operand<T> sparseValues,
Operand<Long> sparseShape,
Class<U> outType)
Factory method to create a class to wrap a new SerializeSparse operation to the graph.
|
static <T extends Number> |
SparseReduceMax.create(Scope scope,
Operand<Long> inputIndices,
Operand<T> inputValues,
Operand<Long> inputShape,
Operand<Integer> reductionAxes,
SparseReduceMax.Options... options)
Factory method to create a class to wrap a new SparseReduceMax operation to the graph.
|
static <T extends Number> |
SparseReduceMaxSparse.create(Scope scope,
Operand<Long> inputIndices,
Operand<T> inputValues,
Operand<Long> inputShape,
Operand<Integer> reductionAxes,
SparseReduceMaxSparse.Options... options)
Factory method to create a class to wrap a new SparseReduceMaxSparse operation to the graph.
|
static <T> SparseReduceSum<T> |
SparseReduceSum.create(Scope scope,
Operand<Long> inputIndices,
Operand<T> inputValues,
Operand<Long> inputShape,
Operand<Integer> reductionAxes,
SparseReduceSum.Options... options)
Factory method to create a class to wrap a new SparseReduceSum operation to the graph.
|
static <T> SparseReduceSumSparse<T> |
SparseReduceSumSparse.create(Scope scope,
Operand<Long> inputIndices,
Operand<T> inputValues,
Operand<Long> inputShape,
Operand<Integer> reductionAxes,
SparseReduceSumSparse.Options... options)
Factory method to create a class to wrap a new SparseReduceSumSparse operation to the graph.
|
static <T extends Number> |
FractionalAvgPoolGrad.create(Scope scope,
Operand<Long> origInputTensorShape,
Operand<T> outBackprop,
Operand<Long> rowPoolingSequence,
Operand<Long> colPoolingSequence,
FractionalAvgPoolGrad.Options... options)
Factory method to create a class to wrap a new FractionalAvgPoolGrad operation to the graph.
|
static <T> SparseSlice<T> |
SparseSlice.create(Scope scope,
Operand<Long> indices,
Operand<T> values,
Operand<Long> shape,
Operand<Long> start,
Operand<Long> size)
Factory method to create a class to wrap a new SparseSlice operation to the graph.
|
static <T> SparseSparseMinimum<T> |
SparseSparseMinimum.create(Scope scope,
Operand<Long> aIndices,
Operand<T> aValues,
Operand<Long> aShape,
Operand<Long> bIndices,
Operand<T> bValues,
Operand<Long> bShape)
Factory method to create a class to wrap a new SparseSparseMinimum operation to the graph.
|
static <T extends Number> |
SparseSparseMaximum.create(Scope scope,
Operand<Long> aIndices,
Operand<T> aValues,
Operand<Long> aShape,
Operand<Long> bIndices,
Operand<T> bValues,
Operand<Long> bShape)
Factory method to create a class to wrap a new SparseSparseMaximum operation to the graph.
|
static <T> EditDistance |
EditDistance.create(Scope scope,
Operand<Long> hypothesisIndices,
Operand<T> hypothesisValues,
Operand<Long> hypothesisShape,
Operand<Long> truthIndices,
Operand<T> truthValues,
Operand<Long> truthShape,
EditDistance.Options... options)
Factory method to create a class to wrap a new EditDistance operation to the graph.
|
static <T,U extends Number> |
SparseAdd.create(Scope scope,
Operand<Long> aIndices,
Operand<T> aValues,
Operand<Long> aShape,
Operand<Long> bIndices,
Operand<T> bValues,
Operand<Long> bShape,
Operand<U> thresh)
Factory method to create a class to wrap a new SparseAdd operation to the graph.
|
static <T> SparseToSparseSetOperation<T> |
SparseToSparseSetOperation.create(Scope scope,
Operand<Long> set1Indices,
Operand<T> set1Values,
Operand<Long> set1Shape,
Operand<Long> set2Indices,
Operand<T> set2Values,
Operand<Long> set2Shape,
String setOperation,
SparseToSparseSetOperation.Options... options)
Factory method to create a class to wrap a new SparseToSparseSetOperation operation to the graph.
|
static <T> SparseDenseCwiseMul<T> |
SparseDenseCwiseMul.create(Scope scope,
Operand<Long> spIndices,
Operand<T> spValues,
Operand<Long> spShape,
Operand<T> dense)
Factory method to create a class to wrap a new SparseDenseCwiseMul operation to the graph.
|
static <T> SparseFillEmptyRows<T> |
SparseFillEmptyRows.create(Scope scope,
Operand<Long> indices,
Operand<T> values,
Operand<Long> denseShape,
Operand<T> defaultValue)
Factory method to create a class to wrap a new SparseFillEmptyRows operation to the graph.
|
static <T> SparseDenseCwiseAdd<T> |
SparseDenseCwiseAdd.create(Scope scope,
Operand<Long> spIndices,
Operand<T> spValues,
Operand<Long> spShape,
Operand<T> dense)
Factory method to create a class to wrap a new SparseDenseCwiseAdd operation to the graph.
|
static <T> SparseDenseCwiseDiv<T> |
SparseDenseCwiseDiv.create(Scope scope,
Operand<Long> spIndices,
Operand<T> spValues,
Operand<Long> spShape,
Operand<T> dense)
Factory method to create a class to wrap a new SparseDenseCwiseDiv operation to the graph.
|
static <T> SetSize |
SetSize.create(Scope scope,
Operand<Long> setIndices,
Operand<T> setValues,
Operand<Long> setShape,
SetSize.Options... options)
Factory method to create a class to wrap a new SetSize operation to the graph.
|
static ExtractJpegShape<Integer> |
ExtractJpegShape.create(Scope scope,
Operand<String> contents)
Factory method to create a class to wrap a new ExtractJpegShape operation to the graph, using default output types.
|
static DecodeJSONExample |
DecodeJSONExample.create(Scope scope,
Operand<String> jsonExamples)
Factory method to create a class to wrap a new DecodeJSONExample operation to the graph.
|
static QueueIsClosed |
QueueIsClosed.create(Scope scope,
Operand<String> handle)
Factory method to create a class to wrap a new QueueIsClosed operation to the graph.
|
static SdcaFprint |
SdcaFprint.create(Scope scope,
Operand<String> input)
Factory method to create a class to wrap a new SdcaFprint operation to the graph.
|
static StringStrip |
StringStrip.create(Scope scope,
Operand<String> input)
Factory method to create a class to wrap a new StringStrip operation to the graph.
|
static DeleteSessionTensor |
DeleteSessionTensor.create(Scope scope,
Operand<String> handle)
Factory method to create a class to wrap a new DeleteSessionTensor operation to the graph.
|
static ReadFile |
ReadFile.create(Scope scope,
Operand<String> filename)
Factory method to create a class to wrap a new ReadFile operation to the graph.
|
static BarrierReadySize |
BarrierReadySize.create(Scope scope,
Operand<String> handle)
Factory method to create a class to wrap a new BarrierReadySize operation to the graph.
|
static GcsConfigureCredentials |
GcsConfigureCredentials.create(Scope scope,
Operand<String> json)
Factory method to create a class to wrap a new GcsConfigureCredentials operation to the graph.
|
static DecodeGif |
DecodeGif.create(Scope scope,
Operand<String> contents)
Factory method to create a class to wrap a new DecodeGif operation to the graph.
|
static MatchingFiles |
MatchingFiles.create(Scope scope,
Operand<String> pattern)
Factory method to create a class to wrap a new MatchingFiles operation to the graph.
|
static BarrierIncompleteSize |
BarrierIncompleteSize.create(Scope scope,
Operand<String> handle)
Factory method to create a class to wrap a new BarrierIncompleteSize operation to the graph.
|
static StringToNumber<Float> |
StringToNumber.create(Scope scope,
Operand<String> stringTensor)
Factory method to create a class to wrap a new StringToNumber operation to the graph, using default output types.
|
static AccumulatorNumAccumulated |
AccumulatorNumAccumulated.create(Scope scope,
Operand<String> handle)
Factory method to create a class to wrap a new AccumulatorNumAccumulated operation to the graph.
|
static DecodeBase64 |
DecodeBase64.create(Scope scope,
Operand<String> input)
Factory method to create a class to wrap a new DecodeBase64 operation to the graph.
|
static BarrierClose |
BarrierClose.create(Scope scope,
Operand<String> handle,
BarrierClose.Options... options)
Factory method to create a class to wrap a new BarrierClose operation to the graph.
|
static <T> DeserializeManySparse<T> |
DeserializeManySparse.create(Scope scope,
Operand<String> serializedSparse,
Class<T> dtype)
Factory method to create a class to wrap a new DeserializeManySparse operation to the graph.
|
static <T> GetSessionTensor<T> |
GetSessionTensor.create(Scope scope,
Operand<String> handle,
Class<T> dtype)
Factory method to create a class to wrap a new GetSessionTensor operation to the graph.
|
static <T> ParseTensor<T> |
ParseTensor.create(Scope scope,
Operand<String> serialized,
Class<T> outType)
Factory method to create a class to wrap a new ParseTensor operation to the graph.
|
static <T extends Number> |
ExtractJpegShape.create(Scope scope,
Operand<String> contents,
Class<T> outputType)
Factory method to create a class to wrap a new ExtractJpegShape operation to the graph.
|
static <T extends Number> |
StringToNumber.create(Scope scope,
Operand<String> stringTensor,
Class<T> outType)
Factory method to create a class to wrap a new StringToNumber operation to the graph.
|
static <T extends Number> |
DecodePng.create(Scope scope,
Operand<String> contents,
Class<T> dtype,
DecodePng.Options... options)
Factory method to create a class to wrap a new DecodePng operation to the graph.
|
static <T extends Number> |
DecodeRaw.create(Scope scope,
Operand<String> bytes,
Class<T> outType,
DecodeRaw.Options... options)
Factory method to create a class to wrap a new DecodeRaw operation to the graph.
|
static DecodeBmp |
DecodeBmp.create(Scope scope,
Operand<String> contents,
DecodeBmp.Options... options)
Factory method to create a class to wrap a new DecodeBmp operation to the graph.
|
static DecodeCompressed |
DecodeCompressed.create(Scope scope,
Operand<String> bytes,
DecodeCompressed.Options... options)
Factory method to create a class to wrap a new DecodeCompressed operation to the graph.
|
static DecodeJpeg |
DecodeJpeg.create(Scope scope,
Operand<String> contents,
DecodeJpeg.Options... options)
Factory method to create a class to wrap a new DecodeJpeg operation to the graph.
|
static DecodePng<UInt8> |
DecodePng.create(Scope scope,
Operand<String> contents,
DecodePng.Options... options)
Factory method to create a class to wrap a new DecodePng operation to the graph, using default output types.
|
static DecodeWav |
DecodeWav.create(Scope scope,
Operand<String> contents,
DecodeWav.Options... options)
Factory method to create a class to wrap a new DecodeWav operation to the graph.
|
static EncodeBase64 |
EncodeBase64.create(Scope scope,
Operand<String> input,
EncodeBase64.Options... options)
Factory method to create a class to wrap a new EncodeBase64 operation to the graph.
|
static DecodeCSV |
DecodeCSV.create(Scope scope,
Operand<String> records,
Iterable<Operand<?>> recordDefaults,
DecodeCSV.Options... options)
Factory method to create a class to wrap a new DecodeCSV operation to the graph.
|
static ParseSingleExample |
ParseSingleExample.create(Scope scope,
Operand<String> serialized,
Iterable<Operand<?>> denseDefaults,
Long numSparse,
List<String> sparseKeys,
List<String> denseKeys,
List<Class<?>> sparseTypes,
List<Shape> denseShapes)
Factory method to create a class to wrap a new ParseSingleExample operation to the graph.
|
static IteratorFromStringHandle |
IteratorFromStringHandle.create(Scope scope,
Operand<String> stringHandle,
List<Class<?>> outputTypes,
IteratorFromStringHandle.Options... options)
Factory method to create a class to wrap a new IteratorFromStringHandle operation to the graph.
|
static IteratorFromStringHandleV2 |
IteratorFromStringHandleV2.create(Scope scope,
Operand<String> stringHandle,
List<Class<?>> outputTypes,
IteratorFromStringHandleV2.Options... options)
Factory method to create a class to wrap a new IteratorFromStringHandleV2 operation to the graph.
|
static ExperimentalLMDBDataset |
ExperimentalLMDBDataset.create(Scope scope,
Operand<String> filenames,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalLMDBDataset operation to the graph.
|
static MultiDeviceIteratorFromStringHandle |
MultiDeviceIteratorFromStringHandle.create(Scope scope,
Operand<String> stringHandle,
List<Class<?>> outputTypes,
MultiDeviceIteratorFromStringHandle.Options... options)
Factory method to create a class to wrap a new MultiDeviceIteratorFromStringHandle operation to the graph.
|
static StringToHashBucketFast |
StringToHashBucketFast.create(Scope scope,
Operand<String> input,
Long numBuckets)
Factory method to create a class to wrap a new StringToHashBucketFast operation to the graph.
|
static StringToHashBucket |
StringToHashBucket.create(Scope scope,
Operand<String> stringTensor,
Long numBuckets)
Factory method to create a class to wrap a new StringToHashBucket operation to the graph.
|
static StringToHashBucketStrong |
StringToHashBucketStrong.create(Scope scope,
Operand<String> input,
Long numBuckets,
List<Long> key)
Factory method to create a class to wrap a new StringToHashBucketStrong operation to the graph.
|
static <T> TensorArrayPack<T> |
TensorArrayPack.create(Scope scope,
Operand<String> handle,
Operand<Float> flowIn,
Class<T> dtype,
TensorArrayPack.Options... options)
Factory method to create a class to wrap a new TensorArrayPack operation to the graph.
|
static AudioSummary |
AudioSummary.create(Scope scope,
Operand<String> tag,
Operand<Float> tensor,
Operand<Float> sampleRate,
AudioSummary.Options... options)
Factory method to create a class to wrap a new AudioSummary operation to the graph.
|
static ShardedFilespec |
ShardedFilespec.create(Scope scope,
Operand<String> basename,
Operand<Integer> numShards)
Factory method to create a class to wrap a new ShardedFilespec operation to the graph.
|
static <T> AccumulatorTakeGradient<T> |
AccumulatorTakeGradient.create(Scope scope,
Operand<String> handle,
Operand<Integer> numRequired,
Class<T> dtype)
Factory method to create a class to wrap a new AccumulatorTakeGradient operation to the graph.
|
static <T> SparseAccumulatorTakeGradient<T> |
SparseAccumulatorTakeGradient.create(Scope scope,
Operand<String> handle,
Operand<Integer> numRequired,
Class<T> dtype)
Factory method to create a class to wrap a new SparseAccumulatorTakeGradient operation to the graph.
|
static DecodeAndCropJpeg |
DecodeAndCropJpeg.create(Scope scope,
Operand<String> contents,
Operand<Integer> cropWindow,
DecodeAndCropJpeg.Options... options)
Factory method to create a class to wrap a new DecodeAndCropJpeg operation to the graph.
|
static BarrierTakeMany |
BarrierTakeMany.create(Scope scope,
Operand<String> handle,
Operand<Integer> numElements,
List<Class<?>> componentTypes,
BarrierTakeMany.Options... options)
Factory method to create a class to wrap a new BarrierTakeMany operation to the graph.
|
static ShardedFilename |
ShardedFilename.create(Scope scope,
Operand<String> basename,
Operand<Integer> shard,
Operand<Integer> numShards)
Factory method to create a class to wrap a new ShardedFilename operation to the graph.
|
static ReduceJoin |
ReduceJoin.create(Scope scope,
Operand<String> inputs,
Operand<Integer> reductionIndices,
ReduceJoin.Options... options)
Factory method to create a class to wrap a new ReduceJoin operation to the graph.
|
static AccumulatorSetGlobalStep |
AccumulatorSetGlobalStep.create(Scope scope,
Operand<String> handle,
Operand<Long> newGlobalStep)
Factory method to create a class to wrap a new AccumulatorSetGlobalStep operation to the graph.
|
static FixedLengthRecordDataset |
FixedLengthRecordDataset.create(Scope scope,
Operand<String> filenames,
Operand<Long> headerBytes,
Operand<Long> recordBytes,
Operand<Long> footerBytes,
Operand<Long> bufferSize)
Factory method to create a class to wrap a new FixedLengthRecordDataset operation to the graph.
|
static <T> SparseAccumulatorApplyGradient |
SparseAccumulatorApplyGradient.create(Scope scope,
Operand<String> handle,
Operand<Long> localStep,
Operand<Long> gradientIndices,
Operand<T> gradientValues,
Operand<Long> gradientShape,
Boolean hasKnownShape)
Factory method to create a class to wrap a new SparseAccumulatorApplyGradient operation to the graph.
|
static <T> AccumulatorApplyGradient |
AccumulatorApplyGradient.create(Scope scope,
Operand<String> handle,
Operand<Long> localStep,
Operand<T> gradient)
Factory method to create a class to wrap a new AccumulatorApplyGradient operation to the graph.
|
static RegexFullMatch |
RegexFullMatch.create(Scope scope,
Operand<String> input,
Operand<String> pattern)
Factory method to create a class to wrap a new RegexFullMatch operation to the graph.
|
static WriteFile |
WriteFile.create(Scope scope,
Operand<String> filename,
Operand<String> contents)
Factory method to create a class to wrap a new WriteFile operation to the graph.
|
static <T> Restore<T> |
Restore.create(Scope scope,
Operand<String> filePattern,
Operand<String> tensorName,
Class<T> dt,
Restore.Options... options)
Factory method to create a class to wrap a new Restore operation to the graph.
|
static Save |
Save.create(Scope scope,
Operand<String> filename,
Operand<String> tensorNames,
Iterable<Operand<?>> data)
Factory method to create a class to wrap a new Save operation to the graph.
|
static ParseSequenceExample |
ParseSequenceExample.create(Scope scope,
Operand<String> serialized,
Operand<String> debugName,
Iterable<Operand<?>> contextDenseDefaults,
List<String> featureListDenseMissingAssumedEmpty,
List<String> contextSparseKeys,
List<String> contextDenseKeys,
List<String> featureListSparseKeys,
List<String> featureListDenseKeys,
List<Class<?>> contextSparseTypes,
List<Class<?>> featureListDenseTypes,
List<Class<?>> featureListSparseTypes,
ParseSequenceExample.Options... options)
Factory method to create a class to wrap a new ParseSequenceExample operation to the graph.
|
static ParseExample |
ParseExample.create(Scope scope,
Operand<String> serialized,
Operand<String> names,
Iterable<Operand<String>> sparseKeys,
Iterable<Operand<String>> denseKeys,
Iterable<Operand<?>> denseDefaults,
List<Class<?>> sparseTypes,
List<Shape> denseShapes)
Factory method to create a class to wrap a new ParseExample operation to the graph.
|
static ParseSingleSequenceExample |
ParseSingleSequenceExample.create(Scope scope,
Operand<String> serialized,
Operand<String> featureListDenseMissingAssumedEmpty,
Iterable<Operand<String>> contextSparseKeys,
Iterable<Operand<String>> contextDenseKeys,
Iterable<Operand<String>> featureListSparseKeys,
Iterable<Operand<String>> featureListDenseKeys,
Iterable<Operand<?>> contextDenseDefaults,
Operand<String> debugName,
List<Class<?>> contextSparseTypes,
List<Class<?>> featureListDenseTypes,
List<Class<?>> featureListSparseTypes,
ParseSingleSequenceExample.Options... options)
Factory method to create a class to wrap a new ParseSingleSequenceExample operation to the graph.
|
static GenerateVocabRemapping |
GenerateVocabRemapping.create(Scope scope,
Operand<String> newVocabFile,
Operand<String> oldVocabFile,
Long newVocabOffset,
Long numNewVocab,
GenerateVocabRemapping.Options... options)
Factory method to create a class to wrap a new GenerateVocabRemapping operation to the graph.
|
static MergeV2Checkpoints |
MergeV2Checkpoints.create(Scope scope,
Operand<String> checkpointPrefixes,
Operand<String> destinationPrefix,
MergeV2Checkpoints.Options... options)
Factory method to create a class to wrap a new MergeV2Checkpoints operation to the graph.
|
static TextLineDataset |
TextLineDataset.create(Scope scope,
Operand<String> filenames,
Operand<String> compressionType,
Operand<Long> bufferSize)
Factory method to create a class to wrap a new TextLineDataset operation to the graph.
|
static TFRecordDataset |
TFRecordDataset.create(Scope scope,
Operand<String> filenames,
Operand<String> compressionType,
Operand<Long> bufferSize)
Factory method to create a class to wrap a new TFRecordDataset operation to the graph.
|
static ExperimentalCSVDataset |
ExperimentalCSVDataset.create(Scope scope,
Operand<String> filenames,
Operand<String> compressionType,
Operand<Long> bufferSize,
Operand<Boolean> header,
Operand<String> fieldDelim,
Operand<Boolean> useQuoteDelim,
Operand<String> naValue,
Operand<Long> selectCols,
Iterable<Operand<?>> recordDefaults,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalCSVDataset operation to the graph.
|
static LoadAndRemapMatrix |
LoadAndRemapMatrix.create(Scope scope,
Operand<String> ckptPath,
Operand<String> oldTensorName,
Operand<Long> rowRemapping,
Operand<Long> colRemapping,
Operand<Float> initializingValues,
Long numRows,
Long numCols,
LoadAndRemapMatrix.Options... options)
Factory method to create a class to wrap a new LoadAndRemapMatrix operation to the graph.
|
static <T> RestoreSlice<T> |
RestoreSlice.create(Scope scope,
Operand<String> filePattern,
Operand<String> tensorName,
Operand<String> shapeAndSlice,
Class<T> dt,
RestoreSlice.Options... options)
Factory method to create a class to wrap a new RestoreSlice operation to the graph.
|
static SaveSlices |
SaveSlices.create(Scope scope,
Operand<String> filename,
Operand<String> tensorNames,
Operand<String> shapesAndSlices,
Iterable<Operand<?>> data)
Factory method to create a class to wrap a new SaveSlices operation to the graph.
|
static SaveV2 |
SaveV2.create(Scope scope,
Operand<String> prefix,
Operand<String> tensorNames,
Operand<String> shapeAndSlices,
Iterable<Operand<?>> tensors)
Factory method to create a class to wrap a new SaveV2 operation to the graph.
|
static RestoreV2 |
RestoreV2.create(Scope scope,
Operand<String> prefix,
Operand<String> tensorNames,
Operand<String> shapeAndSlices,
List<Class<?>> dtypes)
Factory method to create a class to wrap a new RestoreV2 operation to the graph.
|
static SqlDataset |
SqlDataset.create(Scope scope,
Operand<String> driverName,
Operand<String> dataSourceName,
Operand<String> query,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new SqlDataset operation to the graph.
|
static RegexReplace |
RegexReplace.create(Scope scope,
Operand<String> input,
Operand<String> pattern,
Operand<String> rewrite,
RegexReplace.Options... options)
Factory method to create a class to wrap a new RegexReplace operation to the graph.
|
static Rpc |
Rpc.create(Scope scope,
Operand<String> address,
Operand<String> method,
Operand<String> request,
Rpc.Options... options)
Factory method to create a class to wrap a new Rpc operation to the graph.
|
static TryRpc |
TryRpc.create(Scope scope,
Operand<String> address,
Operand<String> method,
Operand<String> request,
TryRpc.Options... options)
Factory method to create a class to wrap a new TryRpc operation to the graph.
|
static <T> BarrierInsertMany |
BarrierInsertMany.create(Scope scope,
Operand<String> handle,
Operand<String> keys,
Operand<T> values,
Long componentIndex)
Factory method to create a class to wrap a new BarrierInsertMany operation to the graph.
|
static StringSplit |
StringSplit.create(Scope scope,
Operand<String> input,
Operand<String> delimiter,
StringSplit.Options... options)
Factory method to create a class to wrap a new StringSplit operation to the graph.
|
static StringSplitV2 |
StringSplitV2.create(Scope scope,
Operand<String> input,
Operand<String> sep,
StringSplitV2.Options... options)
Factory method to create a class to wrap a new StringSplitV2 operation to the graph.
|
static <T extends Number> |
HistogramSummary.create(Scope scope,
Operand<String> tag,
Operand<T> values)
Factory method to create a class to wrap a new HistogramSummary operation to the graph.
|
static <T extends Number> |
ScalarSummary.create(Scope scope,
Operand<String> tags,
Operand<T> values)
Factory method to create a class to wrap a new ScalarSummary operation to the graph.
|
static <T extends Number> |
ImageSummary.create(Scope scope,
Operand<String> tag,
Operand<T> tensor,
ImageSummary.Options... options)
Factory method to create a class to wrap a new ImageSummary operation to the graph.
|
static <T> TensorArrayUnpack |
TensorArrayUnpack.create(Scope scope,
Operand<String> handle,
Operand<T> value,
Operand<Float> flowIn)
Factory method to create a class to wrap a new TensorArrayUnpack operation to the graph.
|
static <T> TensorSummaryV2 |
TensorSummaryV2.create(Scope scope,
Operand<String> tag,
Operand<T> tensor,
Operand<String> serializedSummaryMetadata)
Factory method to create a class to wrap a new TensorSummaryV2 operation to the graph.
|
static <T extends Number> |
Substr.create(Scope scope,
Operand<String> input,
Operand<T> pos,
Operand<T> len)
Factory method to create a class to wrap a new Substr operation to the graph.
|
static PrintV2 |
PrintV2.create(Scope scope,
Operand<String> input,
PrintV2.Options... options)
Factory method to create a class to wrap a new PrintV2 operation to the graph.
|
static StaticRegexFullMatch |
StaticRegexFullMatch.create(Scope scope,
Operand<String> input,
String pattern)
Factory method to create a class to wrap a new StaticRegexFullMatch operation to the graph.
|
static StringLength |
StringLength.create(Scope scope,
Operand<String> input,
StringLength.Options... options)
Factory method to create a class to wrap a new StringLength operation to the graph.
|
static DecodeProtoV2 |
DecodeProtoV2.create(Scope scope,
Operand<String> bytes,
String messageType,
List<String> fieldNames,
List<Class<?>> outputTypes,
DecodeProtoV2.Options... options)
Factory method to create a class to wrap a new DecodeProtoV2 operation to the graph.
|
static StaticRegexReplace |
StaticRegexReplace.create(Scope scope,
Operand<String> input,
String pattern,
String rewrite,
StaticRegexReplace.Options... options)
Factory method to create a class to wrap a new StaticRegexReplace operation to the graph.
|
static <T> Sinh<T> |
Sinh.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Sinh operation to the graph.
|
static <T> FFT2D<T> |
FFT2D.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new FFT2D operation to the graph.
|
static <T> SerializeTensor |
SerializeTensor.create(Scope scope,
Operand<T> tensor)
Factory method to create a class to wrap a new SerializeTensor operation to the graph.
|
static <T> Imag<Float> |
Imag.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Imag operation to the graph, using default output types.
|
static <T> Merge<T> |
Merge.create(Scope scope,
Operand<T> inputs)
Factory method to create a class to wrap a new Merge operation to the graph.
|
static <T> Sqrt<T> |
Sqrt.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Sqrt operation to the graph.
|
static <T> StopGradient<T> |
StopGradient.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new StopGradient operation to the graph.
|
static <T> DebugGradientIdentity<T> |
DebugGradientIdentity.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new DebugGradientIdentity operation to the graph.
|
static <T> Identity<T> |
Identity.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Identity operation to the graph.
|
static <T> GetSessionHandleV2 |
GetSessionHandleV2.create(Scope scope,
Operand<T> value)
Factory method to create a class to wrap a new GetSessionHandleV2 operation to the graph.
|
static <T> Log<T> |
Log.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Log operation to the graph.
|
static <T> Neg<T> |
Neg.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Neg operation to the graph.
|
static <T> DeepCopy<T> |
DeepCopy.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new DeepCopy operation to the graph.
|
static <T> BatchMatrixDeterminant<T> |
BatchMatrixDeterminant.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new BatchMatrixDeterminant operation to the graph.
|
static <T> Exit<T> |
Exit.create(Scope scope,
Operand<T> data)
Factory method to create a class to wrap a new Exit operation to the graph.
|
static <T> RefMerge<T> |
RefMerge.create(Scope scope,
Operand<T> inputs)
Factory method to create a class to wrap a new RefMerge operation to the graph.
|
static <T> GetSessionHandle |
GetSessionHandle.create(Scope scope,
Operand<T> value)
Factory method to create a class to wrap a new GetSessionHandle operation to the graph.
|
static <T> RefNextIteration<T> |
RefNextIteration.create(Scope scope,
Operand<T> data)
Factory method to create a class to wrap a new RefNextIteration operation to the graph.
|
static <T> Cholesky<T> |
Cholesky.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Cholesky operation to the graph.
|
static <T> Sign<T> |
Sign.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Sign operation to the graph.
|
static <T> RefExit<T> |
RefExit.create(Scope scope,
Operand<T> data)
Factory method to create a class to wrap a new RefExit operation to the graph.
|
static <T> Tan<T> |
Tan.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Tan operation to the graph.
|
static <T> Atan<T> |
Atan.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Atan operation to the graph.
|
static <T> RefIdentity<T> |
RefIdentity.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new RefIdentity operation to the graph.
|
static <T> IFFT2D<T> |
IFFT2D.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new IFFT2D operation to the graph.
|
static <T> Snapshot<T> |
Snapshot.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Snapshot operation to the graph.
|
static <T> DebugGradientRefIdentity<T> |
DebugGradientRefIdentity.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new DebugGradientRefIdentity operation to the graph.
|
static <T> ZerosLike<T> |
ZerosLike.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new ZerosLike operation to the graph.
|
static <T> IFFT3D<T> |
IFFT3D.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new IFFT3D operation to the graph.
|
static <T> Reciprocal<T> |
Reciprocal.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Reciprocal operation to the graph.
|
static <T> Acosh<T> |
Acosh.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Acosh operation to the graph.
|
static <T> Relu<T> |
Relu.create(Scope scope,
Operand<T> features)
Factory method to create a class to wrap a new Relu operation to the graph.
|
static <T> Conj<T> |
Conj.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Conj operation to the graph.
|
static <T> Cos<T> |
Cos.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Cos operation to the graph.
|
static <T> Expm1<T> |
Expm1.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Expm1 operation to the graph.
|
static <T> FFT<T> |
FFT.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new FFT operation to the graph.
|
static <T> Atanh<T> |
Atanh.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Atanh operation to the graph.
|
static <T> Angle<Float> |
Angle.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Angle operation to the graph, using default output types.
|
static <T> Negate<T> |
Negate.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Negate operation to the graph.
|
static <T> Round<T> |
Round.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Round operation to the graph.
|
static <T> Square<T> |
Square.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Square operation to the graph.
|
static <T> Shape<Integer> |
Shape.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Shape operation to the graph, using default output types.
|
static <T> MatrixLogarithm<T> |
MatrixLogarithm.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new MatrixLogarithm operation to the graph.
|
static <T> MatrixDiagPart<T> |
MatrixDiagPart.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new MatrixDiagPart operation to the graph.
|
static <T> GuaranteeConst<T> |
GuaranteeConst.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new GuaranteeConst operation to the graph.
|
static <T> IsVariableInitialized |
IsVariableInitialized.create(Scope scope,
Operand<T> ref)
Factory method to create a class to wrap a new IsVariableInitialized operation to the graph.
|
static <T> Diag<T> |
Diag.create(Scope scope,
Operand<T> diagonal)
Factory method to create a class to wrap a new Diag operation to the graph.
|
static <T> Sin<T> |
Sin.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Sin operation to the graph.
|
static <T> Asin<T> |
Asin.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Asin operation to the graph.
|
static <T> ShapeN<Integer> |
ShapeN.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new ShapeN operation to the graph, using default output types.
|
static <T> UniqueWithCounts<T,Integer> |
UniqueWithCounts.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new UniqueWithCounts operation to the graph, using default output types.
|
static <T> Sigmoid<T> |
Sigmoid.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Sigmoid operation to the graph.
|
static <T> Real<Float> |
Real.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Real operation to the graph, using default output types.
|
static <T> Cosh<T> |
Cosh.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Cosh operation to the graph.
|
static <T> MatrixDiag<T> |
MatrixDiag.create(Scope scope,
Operand<T> diagonal)
Factory method to create a class to wrap a new MatrixDiag operation to the graph.
|
static <T> DiagPart<T> |
DiagPart.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new DiagPart operation to the graph.
|
static <T> Tanh<T> |
Tanh.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Tanh operation to the graph.
|
static <T> Acos<T> |
Acos.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Acos operation to the graph.
|
static <T> Rank |
Rank.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Rank operation to the graph.
|
static <T> BatchMatrixDiagPart<T> |
BatchMatrixDiagPart.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new BatchMatrixDiagPart operation to the graph.
|
static <T> FFT3D<T> |
FFT3D.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new FFT3D operation to the graph.
|
static <T> BatchMatrixDiag<T> |
BatchMatrixDiag.create(Scope scope,
Operand<T> diagonal)
Factory method to create a class to wrap a new BatchMatrixDiag operation to the graph.
|
static <T> NextIteration<T> |
NextIteration.create(Scope scope,
Operand<T> data)
Factory method to create a class to wrap a new NextIteration operation to the graph.
|
static <T> Where |
Where.create(Scope scope,
Operand<T> condition)
Factory method to create a class to wrap a new Where operation to the graph.
|
static <T> Unique<T,Integer> |
Unique.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Unique operation to the graph, using default output types.
|
static <T> Log1p<T> |
Log1p.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Log1p operation to the graph.
|
static <T> Rsqrt<T> |
Rsqrt.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Rsqrt operation to the graph.
|
static <T> Size<Integer> |
Size.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new Size operation to the graph, using default output types.
|
static <T> Inv<T> |
Inv.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Inv operation to the graph.
|
static <T> Asinh<T> |
Asinh.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Asinh operation to the graph.
|
static <T> MatrixDeterminant<T> |
MatrixDeterminant.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new MatrixDeterminant operation to the graph.
|
static <T> OnesLike<T> |
OnesLike.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new OnesLike operation to the graph.
|
static <T> LogMatrixDeterminant<T> |
LogMatrixDeterminant.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new LogMatrixDeterminant operation to the graph.
|
static <T> Exp<T> |
Exp.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Exp operation to the graph.
|
static <T> ComplexAbs<Float> |
ComplexAbs.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new ComplexAbs operation to the graph, using default output types.
|
static <T> AddN<T> |
AddN.create(Scope scope,
Operand<T> inputs)
Factory method to create a class to wrap a new AddN operation to the graph.
|
static <T> IFFT<T> |
IFFT.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new IFFT operation to the graph.
|
static <T extends Number> |
Softplus.create(Scope scope,
Operand<T> features)
Factory method to create a class to wrap a new Softplus operation to the graph.
|
static <T extends Number> |
Softsign.create(Scope scope,
Operand<T> features)
Factory method to create a class to wrap a new Softsign operation to the graph.
|
static <T extends Number> |
Floor.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Floor operation to the graph.
|
static <T extends Number> |
Abs.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Abs operation to the graph.
|
static <T extends Number> |
IsFinite.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new IsFinite operation to the graph.
|
static <T extends Number> |
Erf.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Erf operation to the graph.
|
static <T extends Number> |
Lgamma.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Lgamma operation to the graph.
|
static <T extends Number> |
PopulationCount.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new PopulationCount operation to the graph.
|
static <T extends Number> |
InvertPermutation.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new InvertPermutation operation to the graph.
|
static <T extends Number> |
LogSoftmax.create(Scope scope,
Operand<T> logits)
Factory method to create a class to wrap a new LogSoftmax operation to the graph.
|
static <T extends Number> |
IsNan.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new IsNan operation to the graph.
|
static <T extends Number> |
Elu.create(Scope scope,
Operand<T> features)
Factory method to create a class to wrap a new Elu operation to the graph.
|
static <T extends Number> |
BatchSelfAdjointEig.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new BatchSelfAdjointEig operation to the graph.
|
static <T extends Number> |
RGBToHSV.create(Scope scope,
Operand<T> images)
Factory method to create a class to wrap a new RGBToHSV operation to the graph.
|
static <T extends Number> |
Softmax.create(Scope scope,
Operand<T> logits)
Factory method to create a class to wrap a new Softmax operation to the graph.
|
static <T extends Number> |
BatchCholesky.create(Scope scope,
Operand<T> input)
Factory method to create a class to wrap a new BatchCholesky operation to the graph.
|
static <T extends Number> |
BesselI1e.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new BesselI1e operation to the graph.
|
static <T extends Number> |
Relu6.create(Scope scope,
Operand<T> features)
Factory method to create a class to wrap a new Relu6 operation to the graph.
|
static <T extends Number> |
Digamma.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Digamma operation to the graph.
|
static <T extends Number> |
Rint.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Rint operation to the graph.
|
static <T extends Number> |
IsInf.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new IsInf operation to the graph.
|
static <T extends Number> |
Invert.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Invert operation to the graph.
|
static <T extends Number> |
Selu.create(Scope scope,
Operand<T> features)
Factory method to create a class to wrap a new Selu operation to the graph.
|
static <T extends Number> |
BesselI0e.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new BesselI0e operation to the graph.
|
static <T extends Number> |
Erfc.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Erfc operation to the graph.
|
static <T extends Number> |
Ceil.create(Scope scope,
Operand<T> x)
Factory method to create a class to wrap a new Ceil operation to the graph.
|
static <T extends Number> |
HSVToRGB.create(Scope scope,
Operand<T> images)
Factory method to create a class to wrap a new HSVToRGB operation to the graph.
|
static <T extends Number> |
L2Loss.create(Scope scope,
Operand<T> t)
Factory method to create a class to wrap a new L2Loss operation to the graph.
|
static <T> AsString |
AsString.create(Scope scope,
Operand<T> input,
AsString.Options... options)
Factory method to create a class to wrap a new AsString operation to the graph.
|
static <T extends Number> |
BatchMatrixInverse.create(Scope scope,
Operand<T> input,
BatchMatrixInverse.Options... options)
Factory method to create a class to wrap a new BatchMatrixInverse operation to the graph.
|
static <T extends Number> |
BatchSelfAdjointEigV2.create(Scope scope,
Operand<T> input,
BatchSelfAdjointEigV2.Options... options)
Factory method to create a class to wrap a new BatchSelfAdjointEigV2 operation to the graph.
|
static <T> BatchSvd<T> |
BatchSvd.create(Scope scope,
Operand<T> input,
BatchSvd.Options... options)
Factory method to create a class to wrap a new BatchSvd operation to the graph.
|
static <T> BiasAddGrad<T> |
BiasAddGrad.create(Scope scope,
Operand<T> outBackprop,
BiasAddGrad.Options... options)
Factory method to create a class to wrap a new BiasAddGrad operation to the graph.
|
static <T extends Number,U> |
EmptyTensorList.create(Scope scope,
Operand<T> elementShape,
Class<U> elementDtype)
Factory method to create a class to wrap a new EmptyTensorList operation to the graph.
|
static <T,U extends Number> |
UniqueWithCounts.create(Scope scope,
Operand<T> x,
Class<U> outIdx)
Factory method to create a class to wrap a new UniqueWithCounts operation to the graph.
|
static <T,U extends Number> |
Unique.create(Scope scope,
Operand<T> x,
Class<U> outIdx)
Factory method to create a class to wrap a new Unique operation to the graph.
|
static <U extends Number,T> |
Imag.create(Scope scope,
Operand<T> input,
Class<U> Tout)
Factory method to create a class to wrap a new Imag operation to the graph.
|
static <U extends Number,T> |
Angle.create(Scope scope,
Operand<T> input,
Class<U> Tout)
Factory method to create a class to wrap a new Angle operation to the graph.
|
static <U extends Number,T> |
Shape.create(Scope scope,
Operand<T> input,
Class<U> outType)
Factory method to create a class to wrap a new Shape operation to the graph.
|
static <U extends Number,T> |
ShapeN.create(Scope scope,
Operand<T> input,
Class<U> outType)
Factory method to create a class to wrap a new ShapeN operation to the graph.
|
static <U extends Number,T> |
Real.create(Scope scope,
Operand<T> input,
Class<U> Tout)
Factory method to create a class to wrap a new Real operation to the graph.
|
static <U extends Number,T> |
Size.create(Scope scope,
Operand<T> input,
Class<U> outType)
Factory method to create a class to wrap a new Size operation to the graph.
|
static <U extends Number,T> |
ComplexAbs.create(Scope scope,
Operand<T> x,
Class<U> Tout)
Factory method to create a class to wrap a new ComplexAbs operation to the graph.
|
static <U,T> DeserializeSparse<U> |
DeserializeSparse.create(Scope scope,
Operand<T> serializedSparse,
Class<U> dtype)
Factory method to create a class to wrap a new DeserializeSparse operation to the graph.
|
static <U,T> Bitcast<U> |
Bitcast.create(Scope scope,
Operand<T> input,
Class<U> type)
Factory method to create a class to wrap a new Bitcast operation to the graph.
|
static <U,T> Cast<U> |
Cast.create(Scope scope,
Operand<T> x,
Class<U> DstT,
Cast.Options... options)
Factory method to create a class to wrap a new Cast operation to the graph.
|
static <T,U> MutableDenseHashTable |
MutableDenseHashTable.create(Scope scope,
Operand<T> emptyKey,
Class<U> valueDtype,
MutableDenseHashTable.Options... options)
Factory method to create a class to wrap a new MutableDenseHashTable operation to the graph.
|
static <U extends Number,T extends Number> |
RandomNormal.create(Scope scope,
Operand<T> shape,
Class<U> dtype,
RandomNormal.Options... options)
Factory method to create a class to wrap a new RandomNormal operation to the graph.
|
static <U extends Number,T extends Number> |
RandomUniform.create(Scope scope,
Operand<T> shape,
Class<U> dtype,
RandomUniform.Options... options)
Factory method to create a class to wrap a new RandomUniform operation to the graph.
|
static <U extends Number,T extends Number> |
TruncatedNormal.create(Scope scope,
Operand<T> shape,
Class<U> dtype,
TruncatedNormal.Options... options)
Factory method to create a class to wrap a new TruncatedNormal operation to the graph.
|
static <T extends Number> |
DataFormatDimMap.create(Scope scope,
Operand<T> x,
DataFormatDimMap.Options... options)
Factory method to create a class to wrap a new DataFormatDimMap operation to the graph.
|
static <T extends Number> |
DataFormatVecPermute.create(Scope scope,
Operand<T> x,
DataFormatVecPermute.Options... options)
Factory method to create a class to wrap a new DataFormatVecPermute operation to the graph.
|
static <T extends Number> |
EncodePng.create(Scope scope,
Operand<T> image,
EncodePng.Options... options)
Factory method to create a class to wrap a new EncodePng operation to the graph.
|
static <T> Print<T> |
Print.create(Scope scope,
Operand<T> input,
Iterable<Operand<?>> data,
Print.Options... options)
Factory method to create a class to wrap a new Print operation to the graph.
|
static <T extends Number> |
Bucketize.create(Scope scope,
Operand<T> input,
List<Float> boundaries)
Factory method to create a class to wrap a new Bucketize operation to the graph.
|
static <T extends Number> |
FractionalAvgPool.create(Scope scope,
Operand<T> value,
List<Float> poolingRatio,
FractionalAvgPool.Options... options)
Factory method to create a class to wrap a new FractionalAvgPool operation to the graph.
|
static <T extends Number> |
FractionalMaxPool.create(Scope scope,
Operand<T> value,
List<Float> poolingRatio,
FractionalMaxPool.Options... options)
Factory method to create a class to wrap a new FractionalMaxPool operation to the graph.
|
static <T extends Number,U extends Number> |
MaxPoolWithArgmax.create(Scope scope,
Operand<T> input,
List<Long> ksize,
List<Long> strides,
Class<U> Targmax,
String padding)
Factory method to create a class to wrap a new MaxPoolWithArgmax operation to the graph.
|
static <T extends Number> |
ExtractImagePatches.create(Scope scope,
Operand<T> images,
List<Long> ksizes,
List<Long> strides,
List<Long> rates,
String padding)
Factory method to create a class to wrap a new ExtractImagePatches operation to the graph.
|
static <T extends Number> |
MaxPoolWithArgmax.create(Scope scope,
Operand<T> input,
List<Long> ksize,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new MaxPoolWithArgmax operation to the graph, using default output types.
|
static <T extends Number> |
ExtractVolumePatches.create(Scope scope,
Operand<T> input,
List<Long> ksizes,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new ExtractVolumePatches operation to the graph.
|
static <T extends Number> |
AvgPool.create(Scope scope,
Operand<T> value,
List<Long> ksize,
List<Long> strides,
String padding,
AvgPool.Options... options)
Factory method to create a class to wrap a new AvgPool operation to the graph.
|
static <T extends Number> |
AvgPool3D.create(Scope scope,
Operand<T> input,
List<Long> ksize,
List<Long> strides,
String padding,
AvgPool3D.Options... options)
Factory method to create a class to wrap a new AvgPool3D operation to the graph.
|
static <T> MaxPool<T> |
MaxPool.create(Scope scope,
Operand<T> input,
List<Long> ksize,
List<Long> strides,
String padding,
MaxPool.Options... options)
Factory method to create a class to wrap a new MaxPool operation to the graph.
|
static <T extends Number> |
MaxPool3D.create(Scope scope,
Operand<T> input,
List<Long> ksize,
List<Long> strides,
String padding,
MaxPool3D.Options... options)
Factory method to create a class to wrap a new MaxPool3D operation to the graph.
|
static <T extends Number> |
CountUpTo.create(Scope scope,
Operand<T> ref,
Long limit)
Factory method to create a class to wrap a new CountUpTo operation to the graph.
|
static <T> DepthToSpace<T> |
DepthToSpace.create(Scope scope,
Operand<T> input,
Long blockSize,
DepthToSpace.Options... options)
Factory method to create a class to wrap a new DepthToSpace operation to the graph.
|
static <T extends Number> |
CollectiveBcastSend.create(Scope scope,
Operand<T> input,
Long groupSize,
Long groupKey,
Long instanceKey,
Shape shape)
Factory method to create a class to wrap a new CollectiveBcastSend operation to the graph.
|
static <T extends Number> |
CollectiveReduce.create(Scope scope,
Operand<T> input,
Long groupSize,
Long groupKey,
Long instanceKey,
String mergeOp,
String finalOp,
List<Long> subdivOffsets)
Factory method to create a class to wrap a new CollectiveReduce operation to the graph.
|
static <T> SpaceToDepth<T> |
SpaceToDepth.create(Scope scope,
Operand<T> input,
Long blockSize,
SpaceToDepth.Options... options)
Factory method to create a class to wrap a new SpaceToDepth operation to the graph.
|
static <T> Unstack<T> |
Unstack.create(Scope scope,
Operand<T> value,
Long num,
Unstack.Options... options)
Factory method to create a class to wrap a new Unstack operation to the graph.
|
static <T extends Number> |
LRN.create(Scope scope,
Operand<T> input,
LRN.Options... options)
Factory method to create a class to wrap a new LRN operation to the graph.
|
static <T> MatrixInverse<T> |
MatrixInverse.create(Scope scope,
Operand<T> input,
MatrixInverse.Options... options)
Factory method to create a class to wrap a new MatrixInverse operation to the graph.
|
static <T> RefSwitch<T> |
RefSwitch.create(Scope scope,
Operand<T> data,
Operand<Boolean> pred)
Factory method to create a class to wrap a new RefSwitch operation to the graph.
|
static <T> Switch<T> |
Switch.create(Scope scope,
Operand<T> data,
Operand<Boolean> pred)
Factory method to create a class to wrap a new Switch operation to the graph.
|
static <T extends Number> |
DrawBoundingBoxes.create(Scope scope,
Operand<T> images,
Operand<Float> boxes)
Factory method to create a class to wrap a new DrawBoundingBoxes operation to the graph.
|
static <T> RequantizationRange |
RequantizationRange.create(Scope scope,
Operand<T> input,
Operand<Float> inputMin,
Operand<Float> inputMax)
Factory method to create a class to wrap a new RequantizationRange operation to the graph.
|
static <U,T> QuantizeDownAndShrinkRange<U> |
QuantizeDownAndShrinkRange.create(Scope scope,
Operand<T> input,
Operand<Float> inputMin,
Operand<Float> inputMax,
Class<U> outType)
Factory method to create a class to wrap a new QuantizeDownAndShrinkRange operation to the graph.
|
static <U,T> QuantizedRelu<U> |
QuantizedRelu.create(Scope scope,
Operand<T> features,
Operand<Float> minFeatures,
Operand<Float> maxFeatures,
Class<U> outType)
Factory method to create a class to wrap a new QuantizedRelu operation to the graph.
|
static <U,T> QuantizedRelu6<U> |
QuantizedRelu6.create(Scope scope,
Operand<T> features,
Operand<Float> minFeatures,
Operand<Float> maxFeatures,
Class<U> outType)
Factory method to create a class to wrap a new QuantizedRelu6 operation to the graph.
|
static <T> Dequantize |
Dequantize.create(Scope scope,
Operand<T> input,
Operand<Float> minRange,
Operand<Float> maxRange,
Dequantize.Options... options)
Factory method to create a class to wrap a new Dequantize operation to the graph.
|
static <T> QuantizedMaxPool<T> |
QuantizedMaxPool.create(Scope scope,
Operand<T> input,
Operand<Float> minInput,
Operand<Float> maxInput,
List<Long> ksize,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new QuantizedMaxPool operation to the graph.
|
static <T> QuantizedAvgPool<T> |
QuantizedAvgPool.create(Scope scope,
Operand<T> input,
Operand<Float> minInput,
Operand<Float> maxInput,
List<Long> ksize,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new QuantizedAvgPool operation to the graph.
|
static <U,T> QuantizedReluX<U> |
QuantizedReluX.create(Scope scope,
Operand<T> features,
Operand<Float> maxValue,
Operand<Float> minFeatures,
Operand<Float> maxFeatures,
Class<U> outType)
Factory method to create a class to wrap a new QuantizedReluX operation to the graph.
|
static <U,T> Requantize<U> |
Requantize.create(Scope scope,
Operand<T> input,
Operand<Float> inputMin,
Operand<Float> inputMax,
Operand<Float> requestedOutputMin,
Operand<Float> requestedOutputMax,
Class<U> outType)
Factory method to create a class to wrap a new Requantize operation to the graph.
|
static <U,T> QuantizedBatchNormWithGlobalNormalization<U> |
QuantizedBatchNormWithGlobalNormalization.create(Scope scope,
Operand<T> t,
Operand<Float> tMin,
Operand<Float> tMax,
Operand<T> m,
Operand<Float> mMin,
Operand<Float> mMax,
Operand<T> v,
Operand<Float> vMin,
Operand<Float> vMax,
Operand<T> beta,
Operand<Float> betaMin,
Operand<Float> betaMax,
Operand<T> gamma,
Operand<Float> gammaMin,
Operand<Float> gammaMax,
Class<U> outType,
Float varianceEpsilon,
Boolean scaleAfterNormalization)
Factory method to create a class to wrap a new QuantizedBatchNormWithGlobalNormalization operation to the graph.
|
static <T> QuantizedInstanceNorm<T> |
QuantizedInstanceNorm.create(Scope scope,
Operand<T> x,
Operand<Float> xMin,
Operand<Float> xMax,
QuantizedInstanceNorm.Options... options)
Factory method to create a class to wrap a new QuantizedInstanceNorm operation to the graph.
|
static <T extends Number> |
SampleDistortedBoundingBoxV2.create(Scope scope,
Operand<T> imageSize,
Operand<Float> boundingBoxes,
Operand<Float> minObjectCovered,
SampleDistortedBoundingBoxV2.Options... options)
Factory method to create a class to wrap a new SampleDistortedBoundingBoxV2 operation to the graph.
|
static <T extends Number> |
CropAndResize.create(Scope scope,
Operand<T> image,
Operand<Float> boxes,
Operand<Integer> boxInd,
Operand<Integer> cropSize,
CropAndResize.Options... options)
Factory method to create a class to wrap a new CropAndResize operation to the graph.
|
static <T extends Number> |
SampleDistortedBoundingBox.create(Scope scope,
Operand<T> imageSize,
Operand<Float> boundingBoxes,
SampleDistortedBoundingBox.Options... options)
Factory method to create a class to wrap a new SampleDistortedBoundingBox operation to the graph.
|
static <T> TileGrad<T> |
TileGrad.create(Scope scope,
Operand<T> input,
Operand<Integer> multiples)
Factory method to create a class to wrap a new TileGrad operation to the graph.
|
static <T extends Number,U> |
TensorListReserve.create(Scope scope,
Operand<T> elementShape,
Operand<Integer> numElements,
Class<U> elementDtype)
Factory method to create a class to wrap a new TensorListReserve operation to the graph.
|
static <U extends Number,T extends Number> |
Multinomial.create(Scope scope,
Operand<T> logits,
Operand<Integer> numSamples,
Class<U> outputDtype,
Multinomial.Options... options)
Factory method to create a class to wrap a new Multinomial operation to the graph.
|
static <T> DynamicPartition<T> |
DynamicPartition.create(Scope scope,
Operand<T> data,
Operand<Integer> partitions,
Long numPartitions)
Factory method to create a class to wrap a new DynamicPartition operation to the graph.
|
static <T extends Number> |
Multinomial.create(Scope scope,
Operand<T> logits,
Operand<Integer> numSamples,
Multinomial.Options... options)
Factory method to create a class to wrap a new Multinomial operation to the graph, using default output types.
|
static <T extends Number> |
NthElement.create(Scope scope,
Operand<T> input,
Operand<Integer> n,
NthElement.Options... options)
Factory method to create a class to wrap a new NthElement operation to the graph.
|
static <T> QuantizedResizeBilinear<T> |
QuantizedResizeBilinear.create(Scope scope,
Operand<T> images,
Operand<Integer> size,
Operand<Float> min,
Operand<Float> max,
QuantizedResizeBilinear.Options... options)
Factory method to create a class to wrap a new QuantizedResizeBilinear operation to the graph.
|
static <T extends Number> |
FusedResizeAndPadConv2D.create(Scope scope,
Operand<T> input,
Operand<Integer> size,
Operand<Integer> paddings,
Operand<T> filter,
String mode,
List<Long> strides,
String padding,
FusedResizeAndPadConv2D.Options... options)
Factory method to create a class to wrap a new FusedResizeAndPadConv2D operation to the graph.
|
static <T> MaxPoolV2<T> |
MaxPoolV2.create(Scope scope,
Operand<T> input,
Operand<Integer> ksize,
Operand<Integer> strides,
String padding,
MaxPoolV2.Options... options)
Factory method to create a class to wrap a new MaxPoolV2 operation to the graph.
|
static <T> InplaceAdd<T> |
InplaceAdd.create(Scope scope,
Operand<T> x,
Operand<Integer> i,
Operand<T> v)
Factory method to create a class to wrap a new InplaceAdd operation to the graph.
|
static <T> InplaceUpdate<T> |
InplaceUpdate.create(Scope scope,
Operand<T> x,
Operand<Integer> i,
Operand<T> v)
Factory method to create a class to wrap a new InplaceUpdate operation to the graph.
|
static <T> InplaceSub<T> |
InplaceSub.create(Scope scope,
Operand<T> x,
Operand<Integer> i,
Operand<T> v)
Factory method to create a class to wrap a new InplaceSub operation to the graph.
|
static <T extends Number> |
Conv2DBackpropFilter.create(Scope scope,
Operand<T> input,
Operand<Integer> filterSizes,
Operand<T> outBackprop,
List<Long> strides,
String padding,
Conv2DBackpropFilter.Options... options)
Factory method to create a class to wrap a new Conv2DBackpropFilter operation to the graph.
|
static <T extends Number> |
Conv3DBackpropFilterV2.create(Scope scope,
Operand<T> input,
Operand<Integer> filterSizes,
Operand<T> outBackprop,
List<Long> strides,
String padding,
Conv3DBackpropFilterV2.Options... options)
Factory method to create a class to wrap a new Conv3DBackpropFilterV2 operation to the graph.
|
static <T extends Number> |
DepthwiseConv2dNativeBackpropFilter.create(Scope scope,
Operand<T> input,
Operand<Integer> filterSizes,
Operand<T> outBackprop,
List<Long> strides,
String padding,
DepthwiseConv2dNativeBackpropFilter.Options... options)
Factory method to create a class to wrap a new DepthwiseConv2dNativeBackpropFilter operation to the graph.
|
static <T extends Number> |
FusedPadConv2D.create(Scope scope,
Operand<T> input,
Operand<Integer> paddings,
Operand<T> filter,
String mode,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new FusedPadConv2D operation to the graph.
|
static <T extends Number,U extends Number> |
StatelessMultinomial.create(Scope scope,
Operand<T> logits,
Operand<Integer> numSamples,
Operand<U> seed)
Factory method to create a class to wrap a new StatelessMultinomial operation to the graph, using default output types.
|
static <T,U extends Number> |
TensorListScatter.create(Scope scope,
Operand<T> tensor,
Operand<Integer> indices,
Operand<U> elementShape)
Factory method to create a class to wrap a new TensorListScatter operation to the graph.
|
static <V extends Number,T extends Number,U extends Number> |
StatelessMultinomial.create(Scope scope,
Operand<T> logits,
Operand<Integer> numSamples,
Operand<U> seed,
Class<V> outputDtype)
Factory method to create a class to wrap a new StatelessMultinomial operation to the graph.
|
static <U,T extends Number> |
OneHot.create(Scope scope,
Operand<T> indices,
Operand<Integer> depth,
Operand<U> onValue,
Operand<U> offValue,
OneHot.Options... options)
Factory method to create a class to wrap a new OneHot operation to the graph.
|
static <T extends Number> |
ResizeArea.create(Scope scope,
Operand<T> images,
Operand<Integer> size,
ResizeArea.Options... options)
Factory method to create a class to wrap a new ResizeArea operation to the graph.
|
static <T extends Number> |
ResizeBicubic.create(Scope scope,
Operand<T> images,
Operand<Integer> size,
ResizeBicubic.Options... options)
Factory method to create a class to wrap a new ResizeBicubic operation to the graph.
|
static <T extends Number> |
ResizeBilinear.create(Scope scope,
Operand<T> images,
Operand<Integer> size,
ResizeBilinear.Options... options)
Factory method to create a class to wrap a new ResizeBilinear operation to the graph.
|
static <T extends Number> |
ResizeNearestNeighbor.create(Scope scope,
Operand<T> images,
Operand<Integer> size,
ResizeNearestNeighbor.Options... options)
Factory method to create a class to wrap a new ResizeNearestNeighbor operation to the graph.
|
static <T extends Number> |
ResizeNearestNeighborGrad.create(Scope scope,
Operand<T> grads,
Operand<Integer> size,
ResizeNearestNeighborGrad.Options... options)
Factory method to create a class to wrap a new ResizeNearestNeighborGrad operation to the graph.
|
static <T extends Number> |
TopK.create(Scope scope,
Operand<T> input,
Operand<Integer> k,
TopK.Options... options)
Factory method to create a class to wrap a new TopK operation to the graph.
|
static <T> BatchMatrixBandPart<T> |
BatchMatrixBandPart.create(Scope scope,
Operand<T> input,
Operand<Long> numLower,
Operand<Long> numUpper)
Factory method to create a class to wrap a new BatchMatrixBandPart operation to the graph.
|
static <T> Unbatch<T> |
Unbatch.create(Scope scope,
Operand<T> batchedTensor,
Operand<Long> batchIndex,
Operand<Long> id,
Long timeoutMicros,
Unbatch.Options... options)
Factory method to create a class to wrap a new Unbatch operation to the graph.
|
static <T> SparseAddGrad<T> |
SparseAddGrad.create(Scope scope,
Operand<T> backpropValGrad,
Operand<Long> aIndices,
Operand<Long> bIndices,
Operand<Long> sumIndices)
Factory method to create a class to wrap a new SparseAddGrad operation to the graph.
|
static <T> SparseSliceGrad<T> |
SparseSliceGrad.create(Scope scope,
Operand<T> backpropValGrad,
Operand<Long> inputIndices,
Operand<Long> inputStart,
Operand<Long> outputIndices)
Factory method to create a class to wrap a new SparseSliceGrad operation to the graph.
|
static <T> DenseToSparseSetOperation<T> |
DenseToSparseSetOperation.create(Scope scope,
Operand<T> set1,
Operand<Long> set2Indices,
Operand<T> set2Values,
Operand<Long> set2Shape,
String setOperation,
DenseToSparseSetOperation.Options... options)
Factory method to create a class to wrap a new DenseToSparseSetOperation operation to the graph.
|
static <T> UnbatchGrad<T> |
UnbatchGrad.create(Scope scope,
Operand<T> originalInput,
Operand<Long> batchIndex,
Operand<T> grad,
Operand<Long> id,
UnbatchGrad.Options... options)
Factory method to create a class to wrap a new UnbatchGrad operation to the graph.
|
static <T extends Number> |
RandomCrop.create(Scope scope,
Operand<T> image,
Operand<Long> size,
RandomCrop.Options... options)
Factory method to create a class to wrap a new RandomCrop operation to the graph.
|
static <T> InvGrad<T> |
InvGrad.create(Scope scope,
Operand<T> y,
Operand<T> dy)
Factory method to create a class to wrap a new InvGrad operation to the graph.
|
static <T> Multiply<T> |
Multiply.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Multiply operation to the graph.
|
static <T> MatrixSetDiag<T> |
MatrixSetDiag.create(Scope scope,
Operand<T> input,
Operand<T> diagonal)
Factory method to create a class to wrap a new MatrixSetDiag operation to the graph.
|
static <T> Sub<T> |
Sub.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Sub operation to the graph.
|
static <T> LowerBound<Integer> |
LowerBound.create(Scope scope,
Operand<T> sortedInputs,
Operand<T> values)
Factory method to create a class to wrap a new LowerBound operation to the graph, using default output types.
|
static <T> Pow<T> |
Pow.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Pow operation to the graph.
|
static <T> Mul<T> |
Mul.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Mul operation to the graph.
|
static <T> Add<T> |
Add.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Add operation to the graph.
|
static <T> FloorDiv<T> |
FloorDiv.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new FloorDiv operation to the graph.
|
static <T> SquaredDifference<T> |
SquaredDifference.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new SquaredDifference operation to the graph.
|
static <T> TanhGrad<T> |
TanhGrad.create(Scope scope,
Operand<T> y,
Operand<T> dy)
Factory method to create a class to wrap a new TanhGrad operation to the graph.
|
static <T> NotEqual |
NotEqual.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new NotEqual operation to the graph.
|
static <T> SigmoidGrad<T> |
SigmoidGrad.create(Scope scope,
Operand<T> y,
Operand<T> dy)
Factory method to create a class to wrap a new SigmoidGrad operation to the graph.
|
static <T> SetDiff1D<T,Integer> |
SetDiff1D.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new SetDiff1D operation to the graph, using default output types.
|
static <T> Div<T> |
Div.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Div operation to the graph.
|
static <T> TruncateDiv<T> |
TruncateDiv.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new TruncateDiv operation to the graph.
|
static <T> Xlogy<T> |
Xlogy.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Xlogy operation to the graph.
|
static <T> CompareAndBitpack |
CompareAndBitpack.create(Scope scope,
Operand<T> input,
Operand<T> threshold)
Factory method to create a class to wrap a new CompareAndBitpack operation to the graph.
|
static <T> BatchMatrixSetDiag<T> |
BatchMatrixSetDiag.create(Scope scope,
Operand<T> input,
Operand<T> diagonal)
Factory method to create a class to wrap a new BatchMatrixSetDiag operation to the graph.
|
static <T> AddV2<T> |
AddV2.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new AddV2 operation to the graph.
|
static <T> UpperBound<Integer> |
UpperBound.create(Scope scope,
Operand<T> sortedInputs,
Operand<T> values)
Factory method to create a class to wrap a new UpperBound operation to the graph, using default output types.
|
static <T> SqrtGrad<T> |
SqrtGrad.create(Scope scope,
Operand<T> y,
Operand<T> dy)
Factory method to create a class to wrap a new SqrtGrad operation to the graph.
|
static <T> ReciprocalGrad<T> |
ReciprocalGrad.create(Scope scope,
Operand<T> y,
Operand<T> dy)
Factory method to create a class to wrap a new ReciprocalGrad operation to the graph.
|
static <T> Subtract<T> |
Subtract.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Subtract operation to the graph.
|
static <T> RsqrtGrad<T> |
RsqrtGrad.create(Scope scope,
Operand<T> y,
Operand<T> dy)
Factory method to create a class to wrap a new RsqrtGrad operation to the graph.
|
static <T> Equal |
Equal.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Equal operation to the graph.
|
static <T> RealDiv<T> |
RealDiv.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new RealDiv operation to the graph.
|
static <T> Xdivy<T> |
Xdivy.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Xdivy operation to the graph.
|
static <T extends Number> |
Relu6Grad.create(Scope scope,
Operand<T> gradients,
Operand<T> features)
Factory method to create a class to wrap a new Relu6Grad operation to the graph.
|
static <T extends Number> |
BitwiseAnd.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new BitwiseAnd operation to the graph.
|
static <T extends Number> |
CholeskyGrad.create(Scope scope,
Operand<T> l,
Operand<T> grad)
Factory method to create a class to wrap a new CholeskyGrad operation to the graph.
|
static <T extends Number> |
Maximum.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Maximum operation to the graph.
|
static <T extends Number> |
Igammac.create(Scope scope,
Operand<T> a,
Operand<T> x)
Factory method to create a class to wrap a new Igammac operation to the graph.
|
static <T extends Number> |
Minimum.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Minimum operation to the graph.
|
static <T extends Number> |
SoftmaxCrossEntropyWithLogits.create(Scope scope,
Operand<T> features,
Operand<T> labels)
Factory method to create a class to wrap a new SoftmaxCrossEntropyWithLogits operation to the graph.
|
static <T extends Number> |
IgammaGradA.create(Scope scope,
Operand<T> a,
Operand<T> x)
Factory method to create a class to wrap a new IgammaGradA operation to the graph.
|
static <T extends Number> |
LessEqual.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new LessEqual operation to the graph.
|
static <T extends Number> |
GreaterEqual.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new GreaterEqual operation to the graph.
|
static <T extends Number> |
BroadcastDynamicShape.create(Scope scope,
Operand<T> s0,
Operand<T> s1)
Factory method to create a class to wrap a new BroadcastDynamicShape operation to the graph.
|
static <T extends Number> |
BitwiseOr.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new BitwiseOr operation to the graph.
|
static <T extends Number> |
UnravelIndex.create(Scope scope,
Operand<T> indices,
Operand<T> dims)
Factory method to create a class to wrap a new UnravelIndex operation to the graph.
|
static <T extends Number> |
Greater.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Greater operation to the graph.
|
static <T extends Number> |
EluGrad.create(Scope scope,
Operand<T> gradients,
Operand<T> outputs)
Factory method to create a class to wrap a new EluGrad operation to the graph.
|
static <T extends Number> |
SoftsignGrad.create(Scope scope,
Operand<T> gradients,
Operand<T> features)
Factory method to create a class to wrap a new SoftsignGrad operation to the graph.
|
static <T extends Number> |
ReluGrad.create(Scope scope,
Operand<T> gradients,
Operand<T> features)
Factory method to create a class to wrap a new ReluGrad operation to the graph.
|
static <T extends Number> |
BatchCholeskyGrad.create(Scope scope,
Operand<T> l,
Operand<T> grad)
Factory method to create a class to wrap a new BatchCholeskyGrad operation to the graph.
|
static <T extends Number> |
Polygamma.create(Scope scope,
Operand<T> a,
Operand<T> x)
Factory method to create a class to wrap a new Polygamma operation to the graph.
|
static <T extends Number> |
SoftplusGrad.create(Scope scope,
Operand<T> gradients,
Operand<T> features)
Factory method to create a class to wrap a new SoftplusGrad operation to the graph.
|
static <T extends Number> |
LeftShift.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new LeftShift operation to the graph.
|
static <T extends Number> |
Atan2.create(Scope scope,
Operand<T> y,
Operand<T> x)
Factory method to create a class to wrap a new Atan2 operation to the graph.
|
static <T extends Number> |
Cross.create(Scope scope,
Operand<T> a,
Operand<T> b)
Factory method to create a class to wrap a new Cross operation to the graph.
|
static <T extends Number> |
TruncateMod.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new TruncateMod operation to the graph.
|
static <T extends Number> |
Less.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Less operation to the graph.
|
static <T extends Number> |
Mod.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new Mod operation to the graph.
|
static <T extends Number> |
RandomGammaGrad.create(Scope scope,
Operand<T> alpha,
Operand<T> sample)
Factory method to create a class to wrap a new RandomGammaGrad operation to the graph.
|
static <T extends Number> |
DivNoNan.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new DivNoNan operation to the graph.
|
static <T extends Number> |
BroadcastGradientArgs.create(Scope scope,
Operand<T> s0,
Operand<T> s1)
Factory method to create a class to wrap a new BroadcastGradientArgs operation to the graph.
|
static <T extends Number> |
SeluGrad.create(Scope scope,
Operand<T> gradients,
Operand<T> outputs)
Factory method to create a class to wrap a new SeluGrad operation to the graph.
|
static <T extends Number> |
Igamma.create(Scope scope,
Operand<T> a,
Operand<T> x)
Factory method to create a class to wrap a new Igamma operation to the graph.
|
static <T extends Number> |
RightShift.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new RightShift operation to the graph.
|
static <T extends Number> |
Zeta.create(Scope scope,
Operand<T> x,
Operand<T> q)
Factory method to create a class to wrap a new Zeta operation to the graph.
|
static <T extends Number> |
FloorMod.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new FloorMod operation to the graph.
|
static <T extends Number> |
BitwiseXor.create(Scope scope,
Operand<T> x,
Operand<T> y)
Factory method to create a class to wrap a new BitwiseXor operation to the graph.
|
static <T> ApproximateEqual |
ApproximateEqual.create(Scope scope,
Operand<T> x,
Operand<T> y,
ApproximateEqual.Options... options)
Factory method to create a class to wrap a new ApproximateEqual operation to the graph.
|
static <T> Assign<T> |
Assign.create(Scope scope,
Operand<T> ref,
Operand<T> value,
Assign.Options... options)
Factory method to create a class to wrap a new Assign operation to the graph.
|
static <T> AssignAdd<T> |
AssignAdd.create(Scope scope,
Operand<T> ref,
Operand<T> value,
AssignAdd.Options... options)
Factory method to create a class to wrap a new AssignAdd operation to the graph.
|
static <T> AssignSub<T> |
AssignSub.create(Scope scope,
Operand<T> ref,
Operand<T> value,
AssignSub.Options... options)
Factory method to create a class to wrap a new AssignSub operation to the graph.
|
static <T> BatchMatMul<T> |
BatchMatMul.create(Scope scope,
Operand<T> x,
Operand<T> y,
BatchMatMul.Options... options)
Factory method to create a class to wrap a new BatchMatMul operation to the graph.
|
static <T extends Number> |
BatchMatrixSolve.create(Scope scope,
Operand<T> matrix,
Operand<T> rhs,
BatchMatrixSolve.Options... options)
Factory method to create a class to wrap a new BatchMatrixSolve operation to the graph.
|
static <T extends Number> |
BatchMatrixTriangularSolve.create(Scope scope,
Operand<T> matrix,
Operand<T> rhs,
BatchMatrixTriangularSolve.Options... options)
Factory method to create a class to wrap a new BatchMatrixTriangularSolve operation to the graph.
|
static <T> BiasAdd<T> |
BiasAdd.create(Scope scope,
Operand<T> value,
Operand<T> bias,
BiasAdd.Options... options)
Factory method to create a class to wrap a new BiasAdd operation to the graph.
|
static <T,U extends Number> |
SetDiff1D.create(Scope scope,
Operand<T> x,
Operand<T> y,
Class<U> outIdx)
Factory method to create a class to wrap a new SetDiff1D operation to the graph.
|
static <U extends Number,T> |
LowerBound.create(Scope scope,
Operand<T> sortedInputs,
Operand<T> values,
Class<U> outType)
Factory method to create a class to wrap a new LowerBound operation to the graph.
|
static <U extends Number,T> |
UpperBound.create(Scope scope,
Operand<T> sortedInputs,
Operand<T> values,
Class<U> outType)
Factory method to create a class to wrap a new UpperBound operation to the graph.
|
static <U,T extends Number> |
Complex.create(Scope scope,
Operand<T> real,
Operand<T> imag,
Class<U> Tout)
Factory method to create a class to wrap a new Complex operation to the graph.
|
static <T extends Number> |
Dilation2D.create(Scope scope,
Operand<T> input,
Operand<T> filter,
List<Long> strides,
List<Long> rates,
String padding)
Factory method to create a class to wrap a new Dilation2D operation to the graph.
|
static <T extends Number> |
Conv2D.create(Scope scope,
Operand<T> input,
Operand<T> filter,
List<Long> strides,
String padding,
Conv2D.Options... options)
Factory method to create a class to wrap a new Conv2D operation to the graph.
|
static <T extends Number> |
Conv3D.create(Scope scope,
Operand<T> input,
Operand<T> filter,
List<Long> strides,
String padding,
Conv3D.Options... options)
Factory method to create a class to wrap a new Conv3D operation to the graph.
|
static <T extends Number> |
DepthwiseConv2dNative.create(Scope scope,
Operand<T> input,
Operand<T> filter,
List<Long> strides,
String padding,
DepthwiseConv2dNative.Options... options)
Factory method to create a class to wrap a new DepthwiseConv2dNative operation to the graph.
|
static <T> MatMul<T> |
MatMul.create(Scope scope,
Operand<T> a,
Operand<T> b,
MatMul.Options... options)
Factory method to create a class to wrap a new MatMul operation to the graph.
|
static <T> MatrixSolve<T> |
MatrixSolve.create(Scope scope,
Operand<T> matrix,
Operand<T> rhs,
MatrixSolve.Options... options)
Factory method to create a class to wrap a new MatrixSolve operation to the graph.
|
static <T> MatrixTriangularSolve<T> |
MatrixTriangularSolve.create(Scope scope,
Operand<T> matrix,
Operand<T> rhs,
MatrixTriangularSolve.Options... options)
Factory method to create a class to wrap a new MatrixTriangularSolve operation to the graph.
|
static <T extends Number> |
BatchMatrixSolveLs.create(Scope scope,
Operand<T> matrix,
Operand<T> rhs,
Operand<Double> l2Regularizer,
BatchMatrixSolveLs.Options... options)
Factory method to create a class to wrap a new BatchMatrixSolveLs operation to the graph.
|
static <T> MatrixSolveLs<T> |
MatrixSolveLs.create(Scope scope,
Operand<T> matrix,
Operand<T> rhs,
Operand<Double> l2Regularizer,
MatrixSolveLs.Options... options)
Factory method to create a class to wrap a new MatrixSolveLs operation to the graph.
|
static <T extends Number,U extends Number> |
FusedBatchNormGradV2.create(Scope scope,
Operand<T> yBackprop,
Operand<T> x,
Operand<Float> scale,
Operand<U> reserveSpace1,
Operand<U> reserveSpace2,
FusedBatchNormGradV2.Options... options)
Factory method to create a class to wrap a new FusedBatchNormGradV2 operation to the graph.
|
static <T extends Number> |
HistogramFixedWidth.create(Scope scope,
Operand<T> values,
Operand<T> valueRange,
Operand<Integer> nbins)
Factory method to create a class to wrap a new HistogramFixedWidth operation to the graph, using default output types.
|
static <U extends Number,T extends Number> |
HistogramFixedWidth.create(Scope scope,
Operand<T> values,
Operand<T> valueRange,
Operand<Integer> nbins,
Class<U> dtype)
Factory method to create a class to wrap a new HistogramFixedWidth operation to the graph.
|
static <T extends Number> |
NonMaxSuppressionV2.create(Scope scope,
Operand<T> boxes,
Operand<T> scores,
Operand<Integer> maxOutputSize,
Operand<Float> iouThreshold)
Factory method to create a class to wrap a new NonMaxSuppressionV2 operation to the graph.
|
static <T extends Number> |
NonMaxSuppressionV3.create(Scope scope,
Operand<T> boxes,
Operand<T> scores,
Operand<Integer> maxOutputSize,
Operand<Float> iouThreshold,
Operand<Float> scoreThreshold)
Factory method to create a class to wrap a new NonMaxSuppressionV3 operation to the graph.
|
static <T extends Number> |
NonMaxSuppressionV4.create(Scope scope,
Operand<T> boxes,
Operand<T> scores,
Operand<Integer> maxOutputSize,
Operand<Float> iouThreshold,
Operand<Float> scoreThreshold,
NonMaxSuppressionV4.Options... options)
Factory method to create a class to wrap a new NonMaxSuppressionV4 operation to the graph.
|
static <T> ClipByValue<T> |
ClipByValue.create(Scope scope,
Operand<T> t,
Operand<T> clipValueMin,
Operand<T> clipValueMax)
Factory method to create a class to wrap a new ClipByValue operation to the graph.
|
static <T extends Number> |
Range.create(Scope scope,
Operand<T> start,
Operand<T> limit,
Operand<T> delta)
Factory method to create a class to wrap a new Range operation to the graph.
|
static <T extends Number> |
Betainc.create(Scope scope,
Operand<T> a,
Operand<T> b,
Operand<T> x)
Factory method to create a class to wrap a new Betainc operation to the graph.
|
static <T> ApplyGradientDescent<T> |
ApplyGradientDescent.create(Scope scope,
Operand<T> var,
Operand<T> alpha,
Operand<T> delta,
ApplyGradientDescent.Options... options)
Factory method to create a class to wrap a new ApplyGradientDescent operation to the graph.
|
static <T extends Number> |
Dilation2DBackpropFilter.create(Scope scope,
Operand<T> input,
Operand<T> filter,
Operand<T> outBackprop,
List<Long> strides,
List<Long> rates,
String padding)
Factory method to create a class to wrap a new Dilation2DBackpropFilter operation to the graph.
|
static <T extends Number> |
Dilation2DBackpropInput.create(Scope scope,
Operand<T> input,
Operand<T> filter,
Operand<T> outBackprop,
List<Long> strides,
List<Long> rates,
String padding)
Factory method to create a class to wrap a new Dilation2DBackpropInput operation to the graph.
|
static <T extends Number> |
MaxPool3DGradGrad.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<T> grad,
List<Long> ksize,
List<Long> strides,
String padding,
MaxPool3DGradGrad.Options... options)
Factory method to create a class to wrap a new MaxPool3DGradGrad operation to the graph.
|
static <T extends Number> |
MaxPoolGrad.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<T> grad,
List<Long> ksize,
List<Long> strides,
String padding,
MaxPoolGrad.Options... options)
Factory method to create a class to wrap a new MaxPoolGrad operation to the graph.
|
static <T extends Number> |
MaxPoolGradGrad.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<T> grad,
List<Long> ksize,
List<Long> strides,
String padding,
MaxPoolGradGrad.Options... options)
Factory method to create a class to wrap a new MaxPoolGradGrad operation to the graph.
|
static <T extends Number> |
Conv3DBackpropFilter.create(Scope scope,
Operand<T> input,
Operand<T> filter,
Operand<T> outBackprop,
List<Long> strides,
String padding,
Conv3DBackpropFilter.Options... options)
Factory method to create a class to wrap a new Conv3DBackpropFilter operation to the graph.
|
static <T extends Number> |
Conv3DBackpropInput.create(Scope scope,
Operand<T> input,
Operand<T> filter,
Operand<T> outBackprop,
List<Long> strides,
String padding,
Conv3DBackpropInput.Options... options)
Factory method to create a class to wrap a new Conv3DBackpropInput operation to the graph.
|
static <T extends Number> |
LRNGrad.create(Scope scope,
Operand<T> inputGrads,
Operand<T> inputImage,
Operand<T> outputImage,
LRNGrad.Options... options)
Factory method to create a class to wrap a new LRNGrad operation to the graph.
|
static <T extends Number> |
MaxPoolGradGradV2.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<T> grad,
Operand<Integer> ksize,
Operand<Integer> strides,
String padding,
MaxPoolGradGradV2.Options... options)
Factory method to create a class to wrap a new MaxPoolGradGradV2 operation to the graph.
|
static <T extends Number> |
MaxPoolGradV2.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<T> grad,
Operand<Integer> ksize,
Operand<Integer> strides,
String padding,
MaxPoolGradV2.Options... options)
Factory method to create a class to wrap a new MaxPoolGradV2 operation to the graph.
|
static <T extends Number> |
QuantizeAndDequantizeV3.create(Scope scope,
Operand<T> input,
Operand<T> inputMin,
Operand<T> inputMax,
Operand<Integer> numBits,
QuantizeAndDequantizeV3.Options... options)
Factory method to create a class to wrap a new QuantizeAndDequantizeV3 operation to the graph.
|
static <T extends Number> |
FractionalMaxPoolGrad.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<T> outBackprop,
Operand<Long> rowPoolingSequence,
Operand<Long> colPoolingSequence,
FractionalMaxPoolGrad.Options... options)
Factory method to create a class to wrap a new FractionalMaxPoolGrad operation to the graph.
|
static <T> ApplyAdagrad<T> |
ApplyAdagrad.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> lr,
Operand<T> grad,
ApplyAdagrad.Options... options)
Factory method to create a class to wrap a new ApplyAdagrad operation to the graph.
|
static <T extends Number> |
CudnnRNN.create(Scope scope,
Operand<T> input,
Operand<T> inputH,
Operand<T> inputC,
Operand<T> params,
CudnnRNN.Options... options)
Factory method to create a class to wrap a new CudnnRNN operation to the graph.
|
static <T extends Number> |
CudnnRNNV2.create(Scope scope,
Operand<T> input,
Operand<T> inputH,
Operand<T> inputC,
Operand<T> params,
CudnnRNNV2.Options... options)
Factory method to create a class to wrap a new CudnnRNNV2 operation to the graph.
|
static <T> ApplyMomentum<T> |
ApplyMomentum.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> lr,
Operand<T> grad,
Operand<T> momentum,
ApplyMomentum.Options... options)
Factory method to create a class to wrap a new ApplyMomentum operation to the graph.
|
static <T> ApplyProximalGradientDescent<T> |
ApplyProximalGradientDescent.create(Scope scope,
Operand<T> var,
Operand<T> alpha,
Operand<T> l1,
Operand<T> l2,
Operand<T> delta,
ApplyProximalGradientDescent.Options... options)
Factory method to create a class to wrap a new ApplyProximalGradientDescent operation to the graph.
|
static <T> BatchNormWithGlobalNormalizationGrad<T> |
BatchNormWithGlobalNormalizationGrad.create(Scope scope,
Operand<T> t,
Operand<T> m,
Operand<T> v,
Operand<T> gamma,
Operand<T> backprop,
Float varianceEpsilon,
Boolean scaleAfterNormalization)
Factory method to create a class to wrap a new BatchNormWithGlobalNormalizationGrad operation to the graph.
|
static <T> BatchNormWithGlobalNormalization<T> |
BatchNormWithGlobalNormalization.create(Scope scope,
Operand<T> t,
Operand<T> m,
Operand<T> v,
Operand<T> beta,
Operand<T> gamma,
Float varianceEpsilon,
Boolean scaleAfterNormalization)
Factory method to create a class to wrap a new BatchNormWithGlobalNormalization operation to the graph.
|
static <T extends Number> |
FusedBatchNorm.create(Scope scope,
Operand<T> x,
Operand<T> scale,
Operand<T> offset,
Operand<T> mean,
Operand<T> variance,
FusedBatchNorm.Options... options)
Factory method to create a class to wrap a new FusedBatchNorm operation to the graph.
|
static <T extends Number> |
FusedBatchNormGrad.create(Scope scope,
Operand<T> yBackprop,
Operand<T> x,
Operand<T> scale,
Operand<T> reserveSpace1,
Operand<T> reserveSpace2,
FusedBatchNormGrad.Options... options)
Factory method to create a class to wrap a new FusedBatchNormGrad operation to the graph.
|
static <T> ApplyProximalAdagrad<T> |
ApplyProximalAdagrad.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> grad,
ApplyProximalAdagrad.Options... options)
Factory method to create a class to wrap a new ApplyProximalAdagrad operation to the graph.
|
static <T> ApplyAdadelta<T> |
ApplyAdadelta.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> accumUpdate,
Operand<T> lr,
Operand<T> rho,
Operand<T> epsilon,
Operand<T> grad,
ApplyAdadelta.Options... options)
Factory method to create a class to wrap a new ApplyAdadelta operation to the graph.
|
static <T> ApplyAddSign<T> |
ApplyAddSign.create(Scope scope,
Operand<T> var,
Operand<T> m,
Operand<T> lr,
Operand<T> alpha,
Operand<T> signDecay,
Operand<T> beta,
Operand<T> grad,
ApplyAddSign.Options... options)
Factory method to create a class to wrap a new ApplyAddSign operation to the graph.
|
static <T> ApplyPowerSign<T> |
ApplyPowerSign.create(Scope scope,
Operand<T> var,
Operand<T> m,
Operand<T> lr,
Operand<T> logbase,
Operand<T> signDecay,
Operand<T> beta,
Operand<T> grad,
ApplyPowerSign.Options... options)
Factory method to create a class to wrap a new ApplyPowerSign operation to the graph.
|
static <T> ApplyAdagradDA<T> |
ApplyAdagradDA.create(Scope scope,
Operand<T> var,
Operand<T> gradientAccumulator,
Operand<T> gradientSquaredAccumulator,
Operand<T> grad,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<Long> globalStep,
ApplyAdagradDA.Options... options)
Factory method to create a class to wrap a new ApplyAdagradDA operation to the graph.
|
static <T> ApplyFtrl<T> |
ApplyFtrl.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> linear,
Operand<T> grad,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> lrPower,
ApplyFtrl.Options... options)
Factory method to create a class to wrap a new ApplyFtrl operation to the graph.
|
static <T> ApplyRMSProp<T> |
ApplyRMSProp.create(Scope scope,
Operand<T> var,
Operand<T> ms,
Operand<T> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
ApplyRMSProp.Options... options)
Factory method to create a class to wrap a new ApplyRMSProp operation to the graph.
|
static <T> ApplyAdaMax<T> |
ApplyAdaMax.create(Scope scope,
Operand<T> var,
Operand<T> m,
Operand<T> v,
Operand<T> beta1Power,
Operand<T> lr,
Operand<T> beta1,
Operand<T> beta2,
Operand<T> epsilon,
Operand<T> grad,
ApplyAdaMax.Options... options)
Factory method to create a class to wrap a new ApplyAdaMax operation to the graph.
|
static <T> ApplyCenteredRMSProp<T> |
ApplyCenteredRMSProp.create(Scope scope,
Operand<T> var,
Operand<T> mg,
Operand<T> ms,
Operand<T> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
ApplyCenteredRMSProp.Options... options)
Factory method to create a class to wrap a new ApplyCenteredRMSProp operation to the graph.
|
static <T> ApplyFtrlV2<T> |
ApplyFtrlV2.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> linear,
Operand<T> grad,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> l2Shrinkage,
Operand<T> lrPower,
ApplyFtrlV2.Options... options)
Factory method to create a class to wrap a new ApplyFtrlV2 operation to the graph.
|
static <T> ApplyAdam<T> |
ApplyAdam.create(Scope scope,
Operand<T> var,
Operand<T> m,
Operand<T> v,
Operand<T> beta1Power,
Operand<T> beta2Power,
Operand<T> lr,
Operand<T> beta1,
Operand<T> beta2,
Operand<T> epsilon,
Operand<T> grad,
ApplyAdam.Options... options)
Factory method to create a class to wrap a new ApplyAdam operation to the graph.
|
static <T extends Number> |
CudnnRNNBackprop.create(Scope scope,
Operand<T> input,
Operand<T> inputH,
Operand<T> inputC,
Operand<T> params,
Operand<T> output,
Operand<T> outputH,
Operand<T> outputC,
Operand<T> outputBackprop,
Operand<T> outputHBackprop,
Operand<T> outputCBackprop,
Operand<T> reserveSpace,
CudnnRNNBackprop.Options... options)
Factory method to create a class to wrap a new CudnnRNNBackprop operation to the graph.
|
static <T extends Number> |
CudnnRNNBackpropV2.create(Scope scope,
Operand<T> input,
Operand<T> inputH,
Operand<T> inputC,
Operand<T> params,
Operand<T> output,
Operand<T> outputH,
Operand<T> outputC,
Operand<T> outputBackprop,
Operand<T> outputHBackprop,
Operand<T> outputCBackprop,
Operand<T> reserveSpace,
Operand<?> hostReserved,
CudnnRNNBackpropV2.Options... options)
Factory method to create a class to wrap a new CudnnRNNBackpropV2 operation to the graph.
|
static <T,U extends Number> |
SparseApplyCenteredRMSProp.create(Scope scope,
Operand<T> var,
Operand<T> mg,
Operand<T> ms,
Operand<T> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
Operand<U> indices,
SparseApplyCenteredRMSProp.Options... options)
Factory method to create a class to wrap a new SparseApplyCenteredRMSProp operation to the graph.
|
static <T,U extends Number> |
SparseApplyRMSProp.create(Scope scope,
Operand<T> var,
Operand<T> ms,
Operand<T> mom,
Operand<T> lr,
Operand<T> rho,
Operand<T> momentum,
Operand<T> epsilon,
Operand<T> grad,
Operand<U> indices,
SparseApplyRMSProp.Options... options)
Factory method to create a class to wrap a new SparseApplyRMSProp operation to the graph.
|
static <T,U extends Number> |
SparseApplyAdadelta.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> accumUpdate,
Operand<T> lr,
Operand<T> rho,
Operand<T> epsilon,
Operand<T> grad,
Operand<U> indices,
SparseApplyAdadelta.Options... options)
Factory method to create a class to wrap a new SparseApplyAdadelta operation to the graph.
|
static <T,U extends Number> |
SparseApplyProximalAdagrad.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> grad,
Operand<U> indices,
SparseApplyProximalAdagrad.Options... options)
Factory method to create a class to wrap a new SparseApplyProximalAdagrad operation to the graph.
|
static <T,U extends Number> |
SparseApplyProximalGradientDescent.create(Scope scope,
Operand<T> var,
Operand<T> alpha,
Operand<T> l1,
Operand<T> l2,
Operand<T> grad,
Operand<U> indices,
SparseApplyProximalGradientDescent.Options... options)
Factory method to create a class to wrap a new SparseApplyProximalGradientDescent operation to the graph.
|
static <T,U extends Number> |
SparseApplyAdagradDA.create(Scope scope,
Operand<T> var,
Operand<T> gradientAccumulator,
Operand<T> gradientSquaredAccumulator,
Operand<T> grad,
Operand<U> indices,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<Long> globalStep,
SparseApplyAdagradDA.Options... options)
Factory method to create a class to wrap a new SparseApplyAdagradDA operation to the graph.
|
static <T,U extends Number> |
SparseApplyFtrlV2.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> linear,
Operand<T> grad,
Operand<U> indices,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> l2Shrinkage,
Operand<T> lrPower,
SparseApplyFtrlV2.Options... options)
Factory method to create a class to wrap a new SparseApplyFtrlV2 operation to the graph.
|
static <T,U extends Number> |
SparseApplyFtrl.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> linear,
Operand<T> grad,
Operand<U> indices,
Operand<T> lr,
Operand<T> l1,
Operand<T> l2,
Operand<T> lrPower,
SparseApplyFtrl.Options... options)
Factory method to create a class to wrap a new SparseApplyFtrl operation to the graph.
|
static <T,U extends Number> |
SparseApplyMomentum.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> lr,
Operand<T> grad,
Operand<U> indices,
Operand<T> momentum,
SparseApplyMomentum.Options... options)
Factory method to create a class to wrap a new SparseApplyMomentum operation to the graph.
|
static <T,U extends Number> |
SparseApplyAdagrad.create(Scope scope,
Operand<T> var,
Operand<T> accum,
Operand<T> lr,
Operand<T> grad,
Operand<U> indices,
SparseApplyAdagrad.Options... options)
Factory method to create a class to wrap a new SparseApplyAdagrad operation to the graph.
|
static <U,T extends Number> |
StridedSliceGrad.create(Scope scope,
Operand<T> shape,
Operand<T> begin,
Operand<T> end,
Operand<T> strides,
Operand<U> dy,
StridedSliceGrad.Options... options)
Factory method to create a class to wrap a new StridedSliceGrad operation to the graph.
|
static <T extends Number> |
QuantizeAndDequantizeV2.create(Scope scope,
Operand<T> input,
Operand<T> inputMin,
Operand<T> inputMax,
QuantizeAndDequantizeV2.Options... options)
Factory method to create a class to wrap a new QuantizeAndDequantizeV2 operation to the graph.
|
static <T extends Number,U extends Number> |
LinSpace.create(Scope scope,
Operand<T> start,
Operand<T> stop,
Operand<U> num)
Factory method to create a class to wrap a new LinSpace operation to the graph.
|
static <T extends Number,U extends Number> |
MaxPoolGradGradWithArgmax.create(Scope scope,
Operand<T> input,
Operand<T> grad,
Operand<U> argmax,
List<Long> ksize,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new MaxPoolGradGradWithArgmax operation to the graph.
|
static <T extends Number,U extends Number> |
MaxPoolGradWithArgmax.create(Scope scope,
Operand<T> input,
Operand<T> grad,
Operand<U> argmax,
List<Long> ksize,
List<Long> strides,
String padding)
Factory method to create a class to wrap a new MaxPoolGradWithArgmax operation to the graph.
|
static <U extends Number,T extends Number> |
MaxPool3DGrad.create(Scope scope,
Operand<T> origInput,
Operand<T> origOutput,
Operand<U> grad,
List<Long> ksize,
List<Long> strides,
String padding,
MaxPool3DGrad.Options... options)
Factory method to create a class to wrap a new MaxPool3DGrad operation to the graph.
|
static <U,T extends Number> |
SparseToDense.create(Scope scope,
Operand<T> sparseIndices,
Operand<T> outputShape,
Operand<U> sparseValues,
Operand<U> defaultValue,
SparseToDense.Options... options)
Factory method to create a class to wrap a new SparseToDense operation to the graph.
|
static <T> DenseToDenseSetOperation<T> |
DenseToDenseSetOperation.create(Scope scope,
Operand<T> set1,
Operand<T> set2,
String setOperation,
DenseToDenseSetOperation.Options... options)
Factory method to create a class to wrap a new DenseToDenseSetOperation operation to the graph.
|
static <T extends Number,U extends Number> |
SegmentMin.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds)
Factory method to create a class to wrap a new SegmentMin operation to the graph.
|
static <T extends Number,U extends Number> |
StatelessTruncatedNormal.create(Scope scope,
Operand<T> shape,
Operand<U> seed)
Factory method to create a class to wrap a new StatelessTruncatedNormal operation to the graph, using default output types.
|
static <T extends Number,U extends Number> |
StatelessRandomUniform.create(Scope scope,
Operand<T> shape,
Operand<U> seed)
Factory method to create a class to wrap a new StatelessRandomUniform operation to the graph, using default output types.
|
static <T extends Number,U extends Number> |
SparseSoftmaxCrossEntropyWithLogits.create(Scope scope,
Operand<T> features,
Operand<U> labels)
Factory method to create a class to wrap a new SparseSoftmaxCrossEntropyWithLogits operation to the graph.
|
static <T extends Number,U extends Number> |
SegmentMax.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds)
Factory method to create a class to wrap a new SegmentMax operation to the graph.
|
static <T extends Number,U extends Number> |
StatelessRandomNormal.create(Scope scope,
Operand<T> shape,
Operand<U> seed)
Factory method to create a class to wrap a new StatelessRandomNormal operation to the graph, using default output types.
|
static <T,U extends Number> |
TensorListFromTensor.create(Scope scope,
Operand<T> tensor,
Operand<U> elementShape)
Factory method to create a class to wrap a new TensorListFromTensor operation to the graph.
|
static <T,U extends Number> |
Tile.create(Scope scope,
Operand<T> input,
Operand<U> multiples)
Factory method to create a class to wrap a new Tile operation to the graph.
|
static <T,U extends Number> |
SegmentProd.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds)
Factory method to create a class to wrap a new SegmentProd operation to the graph.
|
static <T,U extends Number> |
SegmentMean.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds)
Factory method to create a class to wrap a new SegmentMean operation to the graph.
|
static <T,U extends Number> |
UniqueWithCountsV2.create(Scope scope,
Operand<T> x,
Operand<U> axis)
Factory method to create a class to wrap a new UniqueWithCountsV2 operation to the graph, using default output types.
|
static <T,U extends Number> |
ArgMin.create(Scope scope,
Operand<T> input,
Operand<U> dimension)
Factory method to create a class to wrap a new ArgMin operation to the graph, using default output types.
|
static <T,U extends Number> |
ExpandDims.create(Scope scope,
Operand<T> input,
Operand<U> axis)
Factory method to create a class to wrap a new ExpandDims operation to the graph.
|
static <T,U extends Number> |
UniqueV2.create(Scope scope,
Operand<T> x,
Operand<U> axis)
Factory method to create a class to wrap a new UniqueV2 operation to the graph, using default output types.
|
static <T,U extends Number> |
GatherNd.create(Scope scope,
Operand<T> params,
Operand<U> indices)
Factory method to create a class to wrap a new GatherNd operation to the graph.
|
static <T,U extends Number> |
BroadcastTo.create(Scope scope,
Operand<T> input,
Operand<U> shape)
Factory method to create a class to wrap a new BroadcastTo operation to the graph.
|
static <T,U extends Number> |
Transpose.create(Scope scope,
Operand<T> x,
Operand<U> perm)
Factory method to create a class to wrap a new Transpose operation to the graph.
|
static <T,U extends Number> |
Reshape.create(Scope scope,
Operand<T> tensor,
Operand<U> shape)
Factory method to create a class to wrap a new Reshape operation to the graph.
|
static <T,U extends Number> |
Concat.create(Scope scope,
Operand<T> values,
Operand<U> axis)
Factory method to create a class to wrap a new Concat operation to the graph.
|
static <T,U extends Number> |
SegmentSum.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds)
Factory method to create a class to wrap a new SegmentSum operation to the graph.
|
static <T,U extends Number> |
Pad.create(Scope scope,
Operand<T> input,
Operand<U> paddings)
Factory method to create a class to wrap a new Pad operation to the graph.
|
static <T,U extends Number> |
ConjugateTranspose.create(Scope scope,
Operand<T> x,
Operand<U> perm)
Factory method to create a class to wrap a new ConjugateTranspose operation to the graph.
|
static <T,U extends Number> |
ArgMax.create(Scope scope,
Operand<T> input,
Operand<U> dimension)
Factory method to create a class to wrap a new ArgMax operation to the graph, using default output types.
|
static <T,U extends Number> |
Reverse.create(Scope scope,
Operand<T> tensor,
Operand<U> axis)
Factory method to create a class to wrap a new Reverse operation to the graph.
|
static <U,T extends Number> |
Fill.create(Scope scope,
Operand<T> dims,
Operand<U> value)
Factory method to create a class to wrap a new Fill operation to the graph.
|
static <T,V extends Number,U extends Number> |
UniqueWithCountsV2.create(Scope scope,
Operand<T> x,
Operand<U> axis,
Class<V> outIdx)
Factory method to create a class to wrap a new UniqueWithCountsV2 operation to the graph.
|
static <T,V extends Number,U extends Number> |
UniqueV2.create(Scope scope,
Operand<T> x,
Operand<U> axis,
Class<V> outIdx)
Factory method to create a class to wrap a new UniqueV2 operation to the graph.
|
static <V extends Number,T extends Number,U extends Number> |
StatelessTruncatedNormal.create(Scope scope,
Operand<T> shape,
Operand<U> seed,
Class<V> dtype)
Factory method to create a class to wrap a new StatelessTruncatedNormal operation to the graph.
|
static <V extends Number,T extends Number,U extends Number> |
StatelessRandomUniform.create(Scope scope,
Operand<T> shape,
Operand<U> seed,
Class<V> dtype)
Factory method to create a class to wrap a new StatelessRandomUniform operation to the graph.
|
static <V extends Number,T extends Number,U extends Number> |
StatelessRandomNormal.create(Scope scope,
Operand<T> shape,
Operand<U> seed,
Class<V> dtype)
Factory method to create a class to wrap a new StatelessRandomNormal operation to the graph.
|
static <V extends Number,T,U extends Number> |
ArgMin.create(Scope scope,
Operand<T> input,
Operand<U> dimension,
Class<V> outputType)
Factory method to create a class to wrap a new ArgMin operation to the graph.
|
static <V extends Number,T,U extends Number> |
ArgMax.create(Scope scope,
Operand<T> input,
Operand<U> dimension,
Class<V> outputType)
Factory method to create a class to wrap a new ArgMax operation to the graph.
|
static <V extends Number,T extends Number,U extends Number> |
RandomPoissonV2.create(Scope scope,
Operand<T> shape,
Operand<U> rate,
Class<V> dtype,
RandomPoissonV2.Options... options)
Factory method to create a class to wrap a new RandomPoissonV2 operation to the graph.
|
static <T,U extends Number> |
Cumprod.create(Scope scope,
Operand<T> x,
Operand<U> axis,
Cumprod.Options... options)
Factory method to create a class to wrap a new Cumprod operation to the graph.
|
static <T,U extends Number> |
Cumsum.create(Scope scope,
Operand<T> x,
Operand<U> axis,
Cumsum.Options... options)
Factory method to create a class to wrap a new Cumsum operation to the graph.
|
static <T,U extends Number> |
Gather.create(Scope scope,
Operand<T> params,
Operand<U> indices,
Gather.Options... options)
Factory method to create a class to wrap a new Gather operation to the graph.
|
static <T,U extends Number> |
SpaceToBatch.create(Scope scope,
Operand<T> input,
Operand<U> paddings,
Long blockSize)
Factory method to create a class to wrap a new SpaceToBatch operation to the graph.
|
static <T,U extends Number> |
BatchToSpace.create(Scope scope,
Operand<T> input,
Operand<U> crops,
Long blockSize)
Factory method to create a class to wrap a new BatchToSpace operation to the graph.
|
static <T,U extends Number> |
ReverseSequence.create(Scope scope,
Operand<T> input,
Operand<U> seqLengths,
Long seqDim,
ReverseSequence.Options... options)
Factory method to create a class to wrap a new ReverseSequence operation to the graph.
|
static <T,U extends Number> |
Max.create(Scope scope,
Operand<T> input,
Operand<U> axis,
Max.Options... options)
Factory method to create a class to wrap a new Max operation to the graph.
|
static <T,U extends Number> |
Mean.create(Scope scope,
Operand<T> input,
Operand<U> axis,
Mean.Options... options)
Factory method to create a class to wrap a new Mean operation to the graph.
|
static <T,U extends Number> |
Min.create(Scope scope,
Operand<T> input,
Operand<U> axis,
Min.Options... options)
Factory method to create a class to wrap a new Min operation to the graph.
|
static <T,U extends Number> |
QuantizedReshape.create(Scope scope,
Operand<T> tensor,
Operand<U> shape,
Operand<Float> inputMin,
Operand<Float> inputMax)
Factory method to create a class to wrap a new QuantizedReshape operation to the graph.
|
static <V,T,U> QuantizedAdd<V> |
QuantizedAdd.create(Scope scope,
Operand<T> x,
Operand<U> y,
Operand<Float> minX,
Operand<Float> maxX,
Operand<Float> minY,
Operand<Float> maxY,
Class<V> Toutput)
Factory method to create a class to wrap a new QuantizedAdd operation to the graph.
|
static <V,T,U> QuantizedMul<V> |
QuantizedMul.create(Scope scope,
Operand<T> x,
Operand<U> y,
Operand<Float> minX,
Operand<Float> maxX,
Operand<Float> minY,
Operand<Float> maxY,
Class<V> Toutput)
Factory method to create a class to wrap a new QuantizedMul operation to the graph.
|
static <V,T,U> QuantizedBiasAdd<V> |
QuantizedBiasAdd.create(Scope scope,
Operand<T> input,
Operand<U> bias,
Operand<Float> minInput,
Operand<Float> maxInput,
Operand<Float> minBias,
Operand<Float> maxBias,
Class<V> outType)
Factory method to create a class to wrap a new QuantizedBiasAdd operation to the graph.
|
static <V,T,U,W> QuantizedMatMul<V> |
QuantizedMatMul.create(Scope scope,
Operand<T> a,
Operand<U> b,
Operand<Float> minA,
Operand<Float> maxA,
Operand<Float> minB,
Operand<Float> maxB,
Class<V> Toutput,
Class<W> Tactivation,
QuantizedMatMul.Options... options)
Factory method to create a class to wrap a new QuantizedMatMul operation to the graph.
|
static <V,T,U> QuantizedConv2D<V> |
QuantizedConv2D.create(Scope scope,
Operand<T> input,
Operand<U> filter,
Operand<Float> minInput,
Operand<Float> maxInput,
Operand<Float> minFilter,
Operand<Float> maxFilter,
Class<V> outType,
List<Long> strides,
String padding,
QuantizedConv2D.Options... options)
Factory method to create a class to wrap a new QuantizedConv2D operation to the graph.
|
static <T extends Number,U extends Number> |
SparseSegmentMean.create(Scope scope,
Operand<T> data,
Operand<U> indices,
Operand<Integer> segmentIds)
Factory method to create a class to wrap a new SparseSegmentMean operation to the graph.
|
static <T extends Number,U extends Number> |
SparseSegmentSqrtN.create(Scope scope,
Operand<T> data,
Operand<U> indices,
Operand<Integer> segmentIds)
Factory method to create a class to wrap a new SparseSegmentSqrtN operation to the graph.
|
static <T extends Number,U extends Number> |
SparseSegmentSum.create(Scope scope,
Operand<T> data,
Operand<U> indices,
Operand<Integer> segmentIds)
Factory method to create a class to wrap a new SparseSegmentSum operation to the graph.
|
static <T,U extends Number> |
SplitV.create(Scope scope,
Operand<T> value,
Operand<U> sizeSplits,
Operand<Integer> axis,
Long numSplit)
Factory method to create a class to wrap a new SplitV operation to the graph.
|
static <T extends Number,U extends Number> |
SparseSegmentMeanGrad.create(Scope scope,
Operand<T> grad,
Operand<U> indices,
Operand<Integer> segmentIds,
Operand<Integer> outputDim0)
Factory method to create a class to wrap a new SparseSegmentMeanGrad operation to the graph.
|
static <T extends Number,U extends Number> |
SparseSegmentSqrtNGrad.create(Scope scope,
Operand<T> grad,
Operand<U> indices,
Operand<Integer> segmentIds,
Operand<Integer> outputDim0)
Factory method to create a class to wrap a new SparseSegmentSqrtNGrad operation to the graph.
|
static <T extends Number,U extends Number,V extends Number> |
SparseSegmentMeanWithNumSegments.create(Scope scope,
Operand<T> data,
Operand<U> indices,
Operand<Integer> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new SparseSegmentMeanWithNumSegments operation to the graph.
|
static <T extends Number,U extends Number,V extends Number> |
SparseSegmentSumWithNumSegments.create(Scope scope,
Operand<T> data,
Operand<U> indices,
Operand<Integer> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new SparseSegmentSumWithNumSegments operation to the graph.
|
static <T extends Number,U extends Number,V extends Number> |
SparseSegmentSqrtNWithNumSegments.create(Scope scope,
Operand<T> data,
Operand<U> indices,
Operand<Integer> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new SparseSegmentSqrtNWithNumSegments operation to the graph.
|
static <U,T extends Number> |
SparseTensorDenseMatMul.create(Scope scope,
Operand<T> aIndices,
Operand<U> aValues,
Operand<Long> aShape,
Operand<U> b,
SparseTensorDenseMatMul.Options... options)
Factory method to create a class to wrap a new SparseTensorDenseMatMul operation to the graph.
|
static <T,U extends Number> |
PadV2.create(Scope scope,
Operand<T> input,
Operand<U> paddings,
Operand<T> constantValues)
Factory method to create a class to wrap a new PadV2 operation to the graph.
|
static <T,U extends Number> |
ScatterNdNonAliasingAdd.create(Scope scope,
Operand<T> input,
Operand<U> indices,
Operand<T> updates)
Factory method to create a class to wrap a new ScatterNdNonAliasingAdd operation to the graph.
|
static <U,T extends Number> |
ScatterNd.create(Scope scope,
Operand<T> indices,
Operand<U> updates,
Operand<T> shape)
Factory method to create a class to wrap a new ScatterNd operation to the graph.
|
static <U,T extends Number> |
SparseTensorDenseAdd.create(Scope scope,
Operand<T> aIndices,
Operand<U> aValues,
Operand<T> aShape,
Operand<U> b)
Factory method to create a class to wrap a new SparseTensorDenseAdd operation to the graph.
|
static <T,U extends Number> |
ScatterAdd.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterAdd.Options... options)
Factory method to create a class to wrap a new ScatterAdd operation to the graph.
|
static <T,U extends Number> |
ScatterDiv.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterDiv.Options... options)
Factory method to create a class to wrap a new ScatterDiv operation to the graph.
|
static <T extends Number,U extends Number> |
ScatterMax.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterMax.Options... options)
Factory method to create a class to wrap a new ScatterMax operation to the graph.
|
static <T extends Number,U extends Number> |
ScatterMin.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterMin.Options... options)
Factory method to create a class to wrap a new ScatterMin operation to the graph.
|
static <T,U extends Number> |
ScatterMul.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterMul.Options... options)
Factory method to create a class to wrap a new ScatterMul operation to the graph.
|
static <T,U extends Number> |
ScatterNdAdd.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterNdAdd.Options... options)
Factory method to create a class to wrap a new ScatterNdAdd operation to the graph.
|
static <T,U extends Number> |
ScatterNdSub.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterNdSub.Options... options)
Factory method to create a class to wrap a new ScatterNdSub operation to the graph.
|
static <T,U extends Number> |
ScatterNdUpdate.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterNdUpdate.Options... options)
Factory method to create a class to wrap a new ScatterNdUpdate operation to the graph.
|
static <T,U extends Number> |
ScatterSub.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterSub.Options... options)
Factory method to create a class to wrap a new ScatterSub operation to the graph.
|
static <T,U extends Number> |
ScatterUpdate.create(Scope scope,
Operand<T> ref,
Operand<U> indices,
Operand<T> updates,
ScatterUpdate.Options... options)
Factory method to create a class to wrap a new ScatterUpdate operation to the graph.
|
static <T,U extends Number> |
Slice.create(Scope scope,
Operand<T> input,
Operand<U> begin,
Operand<U> size)
Factory method to create a class to wrap a new Slice operation to the graph.
|
static <T,U extends Number> |
MatrixBandPart.create(Scope scope,
Operand<T> input,
Operand<U> numLower,
Operand<U> numUpper)
Factory method to create a class to wrap a new MatrixBandPart operation to the graph.
|
static <U extends Number,T extends Number> |
Conv3DBackpropInputV2.create(Scope scope,
Operand<T> inputSizes,
Operand<U> filter,
Operand<U> outBackprop,
List<Long> strides,
String padding,
Conv3DBackpropInputV2.Options... options)
Factory method to create a class to wrap a new Conv3DBackpropInputV2 operation to the graph.
|
static <T,U extends Number> |
StridedSliceAssign.create(Scope scope,
Operand<T> ref,
Operand<U> begin,
Operand<U> end,
Operand<U> strides,
Operand<T> value,
StridedSliceAssign.Options... options)
Factory method to create a class to wrap a new StridedSliceAssign operation to the graph.
|
static <T extends Number,U extends Number> |
FusedBatchNormV2.create(Scope scope,
Operand<T> x,
Operand<U> scale,
Operand<U> offset,
Operand<U> mean,
Operand<U> variance,
FusedBatchNormV2.Options... options)
Factory method to create a class to wrap a new FusedBatchNormV2 operation to the graph.
|
static <U extends Number,T extends Number> |
ParameterizedTruncatedNormal.create(Scope scope,
Operand<T> shape,
Operand<U> means,
Operand<U> stdevs,
Operand<U> minvals,
Operand<U> maxvals,
ParameterizedTruncatedNormal.Options... options)
Factory method to create a class to wrap a new ParameterizedTruncatedNormal operation to the graph.
|
static <T,U extends Number> |
StridedSlice.create(Scope scope,
Operand<T> input,
Operand<U> begin,
Operand<U> end,
Operand<U> strides,
StridedSlice.Options... options)
Factory method to create a class to wrap a new StridedSlice operation to the graph.
|
static <U extends Number,T extends Number> |
RandomUniformInt.create(Scope scope,
Operand<T> shape,
Operand<U> minval,
Operand<U> maxval,
RandomUniformInt.Options... options)
Factory method to create a class to wrap a new RandomUniformInt operation to the graph.
|
static <T extends Number,U extends Number,V extends Number> |
UnsortedSegmentMax.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new UnsortedSegmentMax operation to the graph.
|
static <T extends Number,U extends Number,V extends Number> |
UnsortedSegmentMin.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new UnsortedSegmentMin operation to the graph.
|
static <T,U extends Number,V extends Number> |
UnsortedSegmentProd.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new UnsortedSegmentProd operation to the graph.
|
static <T,U extends Number,V extends Number> |
UnsortedSegmentSum.create(Scope scope,
Operand<T> data,
Operand<U> segmentIds,
Operand<V> numSegments)
Factory method to create a class to wrap a new UnsortedSegmentSum operation to the graph.
|
static <T,U extends Number,V extends Number> |
SpaceToBatchND.create(Scope scope,
Operand<T> input,
Operand<U> blockShape,
Operand<V> paddings)
Factory method to create a class to wrap a new SpaceToBatchND operation to the graph.
|
static <T,U extends Number,V extends Number> |
BatchToSpaceND.create(Scope scope,
Operand<T> input,
Operand<U> blockShape,
Operand<V> crops)
Factory method to create a class to wrap a new BatchToSpaceND operation to the graph.
|
static <T,U extends Number,V extends Number> |
GatherV2.create(Scope scope,
Operand<T> params,
Operand<U> indices,
Operand<V> axis)
Factory method to create a class to wrap a new GatherV2 operation to the graph.
|
static <T,U extends Number,V extends Number> |
Roll.create(Scope scope,
Operand<T> input,
Operand<U> shift,
Operand<V> axis)
Factory method to create a class to wrap a new Roll operation to the graph.
|
static <T,U extends Number> |
Prod.create(Scope scope,
Operand<T> input,
Operand<U> axis,
Prod.Options... options)
Factory method to create a class to wrap a new Prod operation to the graph.
|
static <U extends Number,T extends Number> |
RandomGamma.create(Scope scope,
Operand<T> shape,
Operand<U> alpha,
RandomGamma.Options... options)
Factory method to create a class to wrap a new RandomGamma operation to the graph.
|
static <U extends Number,T extends Number> |
RandomPoisson.create(Scope scope,
Operand<T> shape,
Operand<U> rate,
RandomPoisson.Options... options)
Factory method to create a class to wrap a new RandomPoisson operation to the graph.
|
static <T extends Number,U extends Number> |
RandomPoissonV2.create(Scope scope,
Operand<T> shape,
Operand<U> rate,
RandomPoissonV2.Options... options)
Factory method to create a class to wrap a new RandomPoissonV2 operation to the graph, using default output types.
|
static <T,U extends Number> |
ReduceMax.create(Scope scope,
Operand<T> input,
Operand<U> axis,
ReduceMax.Options... options)
Factory method to create a class to wrap a new ReduceMax operation to the graph.
|
static <T,U extends Number> |
ReduceMean.create(Scope scope,
Operand<T> input,
Operand<U> axis,
ReduceMean.Options... options)
Factory method to create a class to wrap a new ReduceMean operation to the graph.
|
static <T,U extends Number> |
ReduceMin.create(Scope scope,
Operand<T> input,
Operand<U> axis,
ReduceMin.Options... options)
Factory method to create a class to wrap a new ReduceMin operation to the graph.
|
static <T,U extends Number> |
ReduceProd.create(Scope scope,
Operand<T> input,
Operand<U> axis,
ReduceProd.Options... options)
Factory method to create a class to wrap a new ReduceProd operation to the graph.
|
static <T,U extends Number> |
ReduceSum.create(Scope scope,
Operand<T> input,
Operand<U> axis,
ReduceSum.Options... options)
Factory method to create a class to wrap a new ReduceSum operation to the graph.
|
static <T extends Number,U extends Number> |
SparseMatMul.create(Scope scope,
Operand<T> a,
Operand<U> b,
SparseMatMul.Options... options)
Factory method to create a class to wrap a new SparseMatMul operation to the graph.
|
static <T,U extends Number> |
MirrorPadGrad.create(Scope scope,
Operand<T> input,
Operand<U> paddings,
String mode)
Factory method to create a class to wrap a new MirrorPadGrad operation to the graph.
|
static <T,U extends Number> |
MirrorPad.create(Scope scope,
Operand<T> input,
Operand<U> paddings,
String mode)
Factory method to create a class to wrap a new MirrorPad operation to the graph.
|
static <T,U extends Number> |
Sum.create(Scope scope,
Operand<T> input,
Operand<U> axis,
Sum.Options... options)
Factory method to create a class to wrap a new Sum operation to the graph.
|
static <T> PreventGradient<T> |
PreventGradient.create(Scope scope,
Operand<T> input,
PreventGradient.Options... options)
Factory method to create a class to wrap a new PreventGradient operation to the graph.
|
static <T> Qr<T> |
Qr.create(Scope scope,
Operand<T> input,
Qr.Options... options)
Factory method to create a class to wrap a new Qr operation to the graph.
|
static <T extends Number> |
QuantizeAndDequantize.create(Scope scope,
Operand<T> input,
QuantizeAndDequantize.Options... options)
Factory method to create a class to wrap a new QuantizeAndDequantize operation to the graph.
|
static <T> RandomShuffle<T> |
RandomShuffle.create(Scope scope,
Operand<T> value,
RandomShuffle.Options... options)
Factory method to create a class to wrap a new RandomShuffle operation to the graph.
|
static <T> SelfAdjointEig<T> |
SelfAdjointEig.create(Scope scope,
Operand<T> input,
SelfAdjointEig.Options... options)
Factory method to create a class to wrap a new SelfAdjointEig operation to the graph.
|
static <T> AccumulateNV2<T> |
AccumulateNV2.create(Scope scope,
Operand<T> inputs,
Shape shape)
Factory method to create a class to wrap a new AccumulateNV2 operation to the graph.
|
static <T> PlaceholderWithDefault<T> |
PlaceholderWithDefault.create(Scope scope,
Operand<T> input,
Shape shape)
Factory method to create a class to wrap a new PlaceholderWithDefault operation to the graph.
|
static <T> EnsureShape<T> |
EnsureShape.create(Scope scope,
Operand<T> input,
Shape shape)
Factory method to create a class to wrap a new EnsureShape operation to the graph.
|
static <T> ParallelConcat<T> |
ParallelConcat.create(Scope scope,
Operand<T> values,
Shape shape)
Factory method to create a class to wrap a new ParallelConcat operation to the graph.
|
static <T> Squeeze<T> |
Squeeze.create(Scope scope,
Operand<T> input,
Squeeze.Options... options)
Factory method to create a class to wrap a new Squeeze operation to the graph.
|
static <T> Stack<T> |
Stack.create(Scope scope,
Operand<T> values,
Stack.Options... options)
Factory method to create a class to wrap a new Stack operation to the graph.
|
static <T> DestroyTemporaryVariable<T> |
DestroyTemporaryVariable.create(Scope scope,
Operand<T> ref,
String varName)
Factory method to create a class to wrap a new DestroyTemporaryVariable operation to the graph.
|
static <T extends Number> |
CheckNumerics.create(Scope scope,
Operand<T> tensor,
String message)
Factory method to create a class to wrap a new CheckNumerics operation to the graph.
|
static <T> Enter<T> |
Enter.create(Scope scope,
Operand<T> data,
String frameName,
Enter.Options... options)
Factory method to create a class to wrap a new Enter operation to the graph.
|
static <T> RefEnter<T> |
RefEnter.create(Scope scope,
Operand<T> data,
String frameName,
RefEnter.Options... options)
Factory method to create a class to wrap a new RefEnter operation to the graph.
|
static <T> Svd<T> |
Svd.create(Scope scope,
Operand<T> input,
Svd.Options... options)
Factory method to create a class to wrap a new Svd operation to the graph.
|
static <T> TensorSummary |
TensorSummary.create(Scope scope,
Operand<T> tensor,
TensorSummary.Options... options)
Factory method to create a class to wrap a new TensorSummary operation to the graph.
|
static <T,U extends Number> |
Zeros.create(Scope scope,
Operand<U> dims,
Class<T> type)
Creates a zeroed tensor given its type and shape.
|
static EncodeJpeg |
EncodeJpeg.create(Scope scope,
Operand<UInt8> image,
EncodeJpeg.Options... options)
Factory method to create a class to wrap a new EncodeJpeg operation to the graph.
|
static <T> TemporaryVariable<T> |
TemporaryVariable.create(Scope scope,
Shape shape,
Class<T> dtype,
TemporaryVariable.Options... options)
Factory method to create a class to wrap a new TemporaryVariable operation to the graph.
|
static <T> Variable<T> |
Variable.create(Scope scope,
Shape shape,
Class<T> dtype,
Variable.Options... options)
Factory method to create a class to wrap a new Variable operation to the graph.
|
static StatsAggregatorHandle |
StatsAggregatorHandle.create(Scope scope,
StatsAggregatorHandle.Options... options)
Factory method to create a class to wrap a new StatsAggregatorHandle operation to the graph.
|
static Constant<String> |
Constant.create(Scope scope,
String data)
Creates a
String constant using the default, UTF-8 encoding. |
static Constant<String> |
Constant.create(Scope scope,
String data,
Charset charset)
Creates a
String constant using a specified encoding. |
static Skipgram |
Skipgram.create(Scope scope,
String filename,
Long batchSize,
Skipgram.Options... options)
Factory method to create a class to wrap a new Skipgram operation to the graph.
|
static RecordInput |
RecordInput.create(Scope scope,
String filePattern,
RecordInput.Options... options)
Factory method to create a class to wrap a new RecordInput operation to the graph.
|
static IteratorV2 |
IteratorV2.create(Scope scope,
String sharedName,
String container,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new IteratorV2 operation to the graph.
|
static ExperimentalMaterializedIndexDatasetHandle |
ExperimentalMaterializedIndexDatasetHandle.create(Scope scope,
String container,
String sharedName,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new ExperimentalMaterializedIndexDatasetHandle operation to the graph.
|
static Iterator |
Iterator.create(Scope scope,
String sharedName,
String container,
List<Class<?>> outputTypes,
List<Shape> outputShapes)
Factory method to create a class to wrap a new Iterator operation to the graph.
|
static BigQueryReader |
BigQueryReader.create(Scope scope,
String projectId,
String datasetId,
String tableId,
List<String> columns,
Long timestampMillis,
BigQueryReader.Options... options)
Factory method to create a class to wrap a new BigQueryReader operation to the graph.
|
static GenerateBigQueryReaderPartitions |
GenerateBigQueryReaderPartitions.create(Scope scope,
String projectId,
String datasetId,
String tableId,
List<String> columns,
Long timestampMillis,
Long numPartitions,
GenerateBigQueryReaderPartitions.Options... options)
Factory method to create a class to wrap a new GenerateBigQueryReaderPartitions operation to the graph.
|
static SummaryWriter |
SummaryWriter.create(Scope scope,
SummaryWriter.Options... options)
Factory method to create a class to wrap a new SummaryWriter operation to the graph.
|
static <T> Const<T> |
Const.create(Scope scope,
Tensor<?> value,
Class<T> dtype)
Factory method to create a class to wrap a new Const operation to the graph.
|
static TextLineReader |
TextLineReader.create(Scope scope,
TextLineReader.Options... options)
Factory method to create a class to wrap a new TextLineReader operation to the graph.
|
static TFRecordReader |
TFRecordReader.create(Scope scope,
TFRecordReader.Options... options)
Factory method to create a class to wrap a new TFRecordReader operation to the graph.
|
static WholeFileReader |
WholeFileReader.create(Scope scope,
WholeFileReader.Options... options)
Factory method to create a class to wrap a new WholeFileReader operation to the graph.
|
Copyright © 2015–2018. All rights reserved.