MCPcopy Create free account

hub / github.com/tensorflow/tfjs / functions

Functions6,022 in github.com/tensorflow/tfjs

MethodapplyGradients
(variableGradients: NamedVariableMap|NamedTensor[])
tfjs-core/src/optimizers/adadelta_optimizer.ts:53
MethodapplyGradients
(variableGradients: NamedVariableMap|NamedTensor[])
tfjs-core/src/optimizers/momentum_optimizer.ts:51
MethodapplyGradients
(variableGradients: NamedVariableMap|NamedTensor[])
tfjs-core/src/optimizers/adagrad_optimizer.ts:48
FunctionargMax
( args: {inputs: ArgMaxInputs, backend: WebGPUBackend, attrs: ArgMaxAttrs})
tfjs-backend-webgpu/src/kernels/ArgMax.ts:25
FunctionargMax
( args: {inputs: ArgMaxInputs, backend: MathBackendWebGL, attrs: ArgMaxAttrs})
tfjs-backend-webgl/src/kernels/ArgMax.ts:25
FunctionargMax_
* Returns the indices of the maximum values along an `axis`. * * The result has the same shape as `input` with the dimension along `axis` * removed
tfjs-core/src/ops/arg_max.ts:52
FunctionargMin
( args: {inputs: ArgMinInputs, backend: WebGPUBackend, attrs: ArgMinAttrs})
tfjs-backend-webgpu/src/kernels/ArgMin.ts:25
FunctionargMin
( args: {inputs: ArgMinInputs, backend: MathBackendWebGL, attrs: ArgMinAttrs})
tfjs-backend-webgl/src/kernels/ArgMin.ts:24
MethodargMin
(arr: number[])
tfjs-layers/src/layers/nlp/tokenizers.ts:395
FunctionargMin_
* Returns the indices of the minimum values along an `axis`. * * The result has the same shape as `input` with the dimension along `axis` * removed
tfjs-core/src/ops/arg_min.ts:52
FunctionarrayBuffer
()
tfjs-core/src/io/http_test.ts:72
Methodas3D
(rows: number, columns: number, depth: number)
tfjs-core/src/public/chained_ops/as3d.ts:24
Methodas5D
( rows: number, columns: number, depth: number, depth2: number, depth3: number)
tfjs-core/src/public/chained_ops/as5d.ts:24
FunctionascendingComparator
(c1: Candidate, c2: Candidate)
tfjs-core/src/backends/non_max_suppression_impl.ts:198
Functionasin_
* Computes asin of the input `tf.Tensor` element-wise: `asin(x)` * * ```js * const x = tf.tensor1d([0, 1, -1, .7]); * * x.asin().print(); // or
tfjs-core/src/ops/asin.ts:38
Functionasinh_
* Computes inverse hyperbolic sin of the input `tf.Tensor` element-wise: * `asinh(x)` * * ```js * const x = tf.tensor1d([0, 1, -1, .7]); * * x.a
tfjs-core/src/ops/asinh.ts:40
FunctionassertAxesAreInnerMostDims
( msg: string, axes: number[], rank: number)
tfjs-core/src/ops/axis_util.ts:68
FunctionassertFn
()
tfjs-core/src/ops/concat_util_test.ts:22
FunctionassertInputCompatibility
* Checks compatibility between the layer and provided inputs. * * This checks that the tensor(s) `input` * verify the input assumptions of th
tfjs-layers/src/engine/topology.ts:752
FunctionassertNotDisposed
()
tfjs-layers/src/engine/container.ts:485
FunctionassertNotDisposed
()
tfjs-layers/src/engine/topology.ts:1521
FunctionassertParamsConsistent
(shapes: number[][], axis: number)
tfjs-core/src/ops/concat_util.ts:20
FunctionassertParamsValid
( input: TensorInfo, begin: number[], size: number[])
tfjs-core/src/ops/slice_util.ts:83
FunctionassignToTypedArray
( data: TypedArray, real: number, imag: number, index: number)
tfjs-core/src/backends/complex_util.ts:123
FunctionasyncTransform
(x: any)
tfjs-data/src/util/deep_map_test.ts:46
Functionatan2_
* Computes arctangent of `tf.Tensor`s a / b element-wise: `atan2(a, b)`. * Supports broadcasting. * * ```js * const a = tf.tensor1d([1.0, 1.0, -1.
tfjs-core/src/ops/atan2.ts:44
Functionatan_
* Computes atan of the input `tf.Tensor` element-wise: `atan(x)` * * ```js * const x = tf.tensor1d([0, 1, -1, .7]); * * x.atan().print(); // or
tfjs-core/src/ops/atan.ts:39
Functionatanh_
* Computes inverse hyperbolic tan of the input `tf.Tensor` element-wise: * `atanh(x)` * * ```js * const x = tf.tensor1d([0, .1, -.1, .7]); * * x
tfjs-core/src/ops/atanh.ts:40
Functionavailable_output_formats
Generate the output formats for given input format. Args: ansowers: user selected parameter dict.
tfjs-converter/python/tensorflowjs/converters/wizard.py:247
Functionavailable_signature_names
Generate the available saved model signatures from the proto file and selected tags. Args: ansowers: user selected parameter dict.
tfjs-converter/python/tensorflowjs/converters/wizard.py:294
Functionavailable_tags
Generate the available saved model tags from the proto file. Args: ansowers: user selected parameter dict.
tfjs-converter/python/tensorflowjs/converters/wizard.py:280
Functionaverage
(args?: LayerArgs)
tfjs-layers/src/exports_layers.ts:732
Functionaverage
(config?: SymbolicTensor[]|Tensor[]|LayerArgs)
tfjs-layers/src/layers/merge.ts:478
FunctionavgPool
( args: {inputs: AvgPoolInputs, backend: WebGPUBackend, attrs: AvgPoolAttrs})
tfjs-backend-webgpu/src/kernels/AvgPool.ts:22
FunctionavgPool
(args: { inputs: AvgPoolInputs, backend: MathBackendWebGL, attrs: AvgPoolAttrs })
tfjs-backend-webgl/src/kernels/AvgPool.ts:24
FunctionavgPool
( args: {inputs: AvgPoolInputs, backend: BackendWasm, attrs: AvgPoolAttrs})
tfjs-backend-wasm/src/kernels/AvgPool.ts:47
FunctionavgPool1d
(args: Pooling1DLayerArgs)
tfjs-layers/src/exports_layers.ts:948
FunctionavgPool2d
(args: Pooling2DLayerArgs)
tfjs-layers/src/exports_layers.ts:983
FunctionavgPool3D
(args: { inputs: AvgPool3DInputs, backend: MathBackendCPU, attrs: AvgPool3DAttrs })
tfjs-backend-cpu/src/kernels/AvgPool3D.ts:24
FunctionavgPool3D
(args: { inputs: AvgPool3DInputs, backend: WebGPUBackend, attrs: AvgPool3DAttrs })
tfjs-backend-webgpu/src/kernels/AvgPool3D.ts:22
FunctionavgPool3D
(args: { inputs: AvgPool3DInputs, backend: MathBackendWebGL, attrs: AvgPool3DAttrs })
tfjs-backend-webgl/src/kernels/AvgPool3D.ts:22
FunctionavgPool3D
(args: { inputs: AvgPool3DInputs, attrs: AvgPool3DAttrs, backend: BackendWasm, })
tfjs-backend-wasm/src/kernels/AvgPool3D.ts:58
FunctionavgPool3DGrad
(args: { inputs: AvgPool3DGradInputs, backend: MathBackendCPU, attrs: AvgPool3DGradAttrs })
tfjs-backend-cpu/src/kernels/AvgPool3DGrad.ts:23
FunctionavgPool3DGrad
(args: { inputs: AvgPool3DGradInputs, backend: WebGPUBackend, attrs: AvgPool3DGradAttrs })
tfjs-backend-webgpu/src/kernels/AvgPool3DGrad.ts:23
FunctionavgPool3DGrad
(args: { inputs: AvgPool3DGradInputs, backend: MathBackendWebGL, attrs: AvgPool3DGradAttrs })
tfjs-backend-webgl/src/kernels/AvgPool3DGrad.ts:22
FunctionavgPool3DGrad
(args: { inputs: AvgPool3DGradInputs, attrs: AvgPool3DGradAttrs, backend: BackendWasm, })
tfjs-backend-wasm/src/kernels/AvgPool3DGrad.ts:62
FunctionavgPool3d
(args: Pooling3DLayerArgs)
tfjs-layers/src/exports_layers.ts:1016
FunctionavgPool3dGrad_
* Computes the backprop of a 3d avg pool. * * @param dy The dy error, of rank 5 of shape * [batchSize, depth, height, width, channels]. * assu
tfjs-core/src/ops/avg_pool_3d_grad.ts:52
FunctionavgPool3d_
* Computes the 3D average pooling. * * ```js * const x = tf.tensor5d([1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 2, 2, 1]); * const result = tf.avgPool3d(x,
tfjs-core/src/ops/avg_pool_3d.ts:68
FunctionavgPoolGrad
(args: { inputs: AvgPoolGradInputs, backend: WebGPUBackend, attrs: AvgPoolGradAttrs })
tfjs-backend-webgpu/src/kernels/AvgPoolGrad.ts:24
FunctionavgPoolGrad
(args: { inputs: AvgPoolGradInputs, backend: MathBackendWebGL, attrs: AvgPoolGradAttrs })
tfjs-backend-webgl/src/kernels/AvgPoolGrad.ts:23
FunctionavgPoolGrad
(args: { inputs: AvgPoolGradInputs, attrs: AvgPoolGradAttrs, backend: BackendWasm, })
tfjs-backend-wasm/src/kernels/AvgPoolGrad.ts:53
FunctionavgPoolGrad_
* Computes the backprop of an 2D avg pool. * * @param dy The dy error, of rank 4 or rank 3 of shape * [batchSize, height, width, channels]. If
tfjs-core/src/ops/avg_pool_grad.ts:49
FunctionavgPool_
* Computes the 2D average pooling of an image. * * @param x The input tensor, of rank 4 or rank 3 of shape * `[batch, height, width, inChannels
tfjs-core/src/ops/avg_pool.ts:54
FunctionavgPooling1d
(args: Pooling1DLayerArgs)
tfjs-layers/src/exports_layers.ts:953
FunctionavgPooling2d
(args: Pooling2DLayerArgs)
tfjs-layers/src/exports_layers.ts:988
FunctionavgPooling3d
(args: Pooling3DLayerArgs)
tfjs-layers/src/exports_layers.ts:1021
Methodbackbone
* A `LayersModel` instance providing the backbone submodel.
tfjs-layers/src/layers/nlp/models/task.ts:64
MethodbackboneCls
( cls: serialization.SerializableConstructor<T> )
tfjs-layers/src/layers/nlp/models/task.ts:97
MethodbackwardsFunc
(dy: T, saved: Tensor[])
tfjs-core/src/engine.ts:1190
FunctionbandPart_
* Copy a tensor setting everything outside a central band in each innermost * matrix to zero. * * The band part is computed as follows: Assume inpu
tfjs-core/src/ops/linalg/band_part.ts:76
FunctionbasicLSTMCell_
* Computes the next state and output of a BasicLSTMCell. * * Returns `[newC, newH]`. * * Derived from tf.contrib.rnn.BasicLSTMCell. * * @param f
tfjs-core/src/ops/basic_lstm_cell.ts:47
Functionbatch
* Groups elements into batches. * * It is assumed that each of the incoming dataset elements has the same * structure -- i.e. the same set of
tfjs-data/src/dataset.ts:136
FunctionbatchFlatten
(x: Tensor)
tfjs-layers/src/backend/tfjs_backend.ts:133
FunctionbatchMatMul
(args: { inputs: BatchMatMulInputs, attrs: BatchMatMulAttrs, backend: WebGPUBackend })
tfjs-backend-webgpu/src/kernels/BatchMatMul.ts:23
FunctionbatchMatMul
(args: { inputs: BatchMatMulInputs, attrs: BatchMatMulAttrs, backend: MathBackendWebGL })
tfjs-backend-webgl/src/kernels/BatchMatMul.ts:23
FunctionbatchMatMul
(args: { inputs: BatchMatMulInputs, backend: BackendWasm, attrs: BatchMatMulAttrs })
tfjs-backend-wasm/src/kernels/BatchMatMul.ts:43
FunctionbatchNorm
({inputs, backend, attrs})
tfjs-backend-webgl/src/kernels/BatchNorm.ts:29
FunctionbatchNorm2d_
* Batch normalization, strictly for 2D. For the more relaxed version, see * `tf.batchNorm`. * * @param x The input Tensor. * @param mean A mean Te
tfjs-core/src/ops/batchnorm2d.ts:36
FunctionbatchNorm3d_
* Batch normalization, strictly for 3D. For the more relaxed version, see * `tf.batchNorm`. * * @param x The input Tensor. * @param mean A mean Te
tfjs-core/src/ops/batchnorm3d.ts:36
FunctionbatchNorm4d_
* Batch normalization, strictly for 4D. For the more relaxed version, see * `tf.batchNorm`. * * @param x The input Tensor. * @param mean A mean Te
tfjs-core/src/ops/batchnorm4d.ts:36
FunctionbatchNorm_
* Batch normalization. * * As described in * [http://arxiv.org/abs/1502.03167](http://arxiv.org/abs/1502.03167). * * Mean, variance, scale, and o
tfjs-core/src/ops/batchnorm.ts:57
FunctionbatchNormalization
(args?: BatchNormalizationLayerArgs)
tfjs-layers/src/exports_layers.ts:876
FunctionbatchToSpaceND
(args: { inputs: BatchToSpaceNDInputs, backend: WebGPUBackend, attrs: BatchToSpaceNDAttrs })
tfjs-backend-webgpu/src/kernels/BatchToSpaceND.ts:26
FunctionbatchToSpaceND
(args: { inputs: BatchToSpaceNDInputs, backend: MathBackendWebGL, attrs: BatchToSpaceNDAttrs })
tfjs-backend-webgl/src/kernels/BatchToSpaceND.ts:26
FunctionbatchToSpaceND
(args: { inputs: BatchToSpaceNDInputs, backend: BackendWasm, attrs: BatchToSpaceNDAttrs })
tfjs-backend-wasm/src/kernels/BatchToSpaceND.ts:26
FunctionbatchToSpaceND_
* This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of * shape `blockShape + [batch]`, interleaves these blocks back into the g
tfjs-core/src/ops/batch_to_space_nd.ts:77
FunctionbenchmarkAll
* Creates and runs benchmark configurations for each model-backend pairing. * * @param browsers The target browsers to run benchmark. * @param {{ba
e2e/benchmarks/browserstack-benchmark/app.js:114
Methodbias
()
tfjs-layers/src/layers/nlp/einsum_dense.ts:373
FunctionbiasAdd
( x: Tensor, bias: Tensor, dataFormat?: DataFormat)
tfjs-layers/src/backend/tfjs_backend.ts:633
Functionbidirectional
(args: BidirectionalLayerArgs)
tfjs-layers/src/exports_layers.ts:1527
FunctionbinaryAccuracy
(yTrue: Tensor, yPred: Tensor)
tfjs-layers/src/metrics.ts:24
FunctionbinaryAccuracy
(yTrue: Tensor, yPred: Tensor)
tfjs-layers/src/exports_metrics.ts:44
FunctionbinaryCrossentropy
(yTrue: Tensor, yPred: Tensor)
tfjs-layers/src/metrics.ts:88
FunctionbinaryCrossentropy
(yTrue: Tensor, yPred: Tensor)
tfjs-layers/src/losses.ts:193
FunctionbinaryCrossentropy
(yTrue: Tensor, yPred: Tensor)
tfjs-layers/src/exports_metrics.ts:65
Functionbincount
( args: {inputs: BincountInputs, backend: WebGPUBackend, attrs: BincountAttrs})
tfjs-backend-webgpu/src/kernels/Bincount.ts:25
Functionbincount
(args: { inputs: BincountInputs, backend: MathBackendWebGL, attrs: BincountAttrs })
tfjs-backend-webgl/src/kernels/Bincount.ts:23
Functionbincount
( args: {backend: BackendWasm, inputs: BincountInputs, attrs: BincountAttrs})
tfjs-backend-wasm/src/kernels/Bincount.ts:38
Functionbincount_
* Outputs a vector with length `size` and the same dtype as `weights`. * * If `weights` are empty, then index `i` stores the number of times the val
tfjs-core/src/ops/bincount.ts:46
FunctionbindCanvasToFramebuffer
(gl: WebGLRenderingContext)
tfjs-backend-webgl/src/webgl_util.ts:281
FunctionbindColorTextureToFramebuffer
( gl: WebGLRenderingContext, texture: WebGLTexture, framebuffer: WebGLFramebuffer)
tfjs-backend-webgl/src/webgl_util.ts:287
FunctionbindTextureToProgramUniformSampler
( gl: WebGLRenderingContext, texture: WebGLTexture, uniformSamplerLocation: WebGLUniformLocation, text
tfjs-backend-webgl/src/webgl_util.ts:274
FunctionbindVertexBufferToProgramAttribute
( gl: WebGLRenderingContext, program: WebGLProgram, attribute: string, buffer: WebGLBuffer, arrayEntri
tfjs-backend-webgl/src/webgl_util.ts:226
FunctionbindVertexProgramAttributeStreams
( gl: WebGLRenderingContext, program: WebGLProgram, vertexBuffer: WebGLBuffer)
tfjs-backend-webgl/src/gpgpu_util.ts:166
FunctionbitwiseAnd_
* Bitwise `AND` operation for input tensors. * * Given two input tensors, returns a new tensor * with the `AND` calculated values. * * The method
tfjs-core/src/ops/bitwise_and.ts:48
MethodblockUntilAllProgramsCompleted
()
tfjs-backend-webgl/src/gpgpu_context.ts:469
FunctionbooleanMaskAsync_
* Apply boolean mask to tensor. * * ```js * const tensor = tf.tensor2d([1, 2, 3, 4, 5, 6], [3, 2]); * const mask = tf.tensor1d([1, 0, 1], 'bool');
tfjs-core/src/ops/boolean_mask.ts:46
Methodbroadcast
(v: Tensor)
tfjs-layers/src/layers/normalization.ts:584
FunctionbroadcastArgs
(args: { inputs: BroadcastArgsInputs, backend: MathBackendCPU, })
tfjs-backend-cpu/src/kernels/BroadcastArgs.ts:22
← previousnext →3,101–3,200 of 6,022, ranked by callers