/**
|
* @license
|
* Copyright 2018 Google LLC. All Rights Reserved.
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
* =============================================================================
|
*/
|
import { inferShape } from '../tensor_util_env';
|
import { makeTensor } from './tensor_ops_util';
|
/**
|
* Creates a `tf.Tensor` with the provided values, shape and dtype.
|
*
|
* ```js
|
* // Pass an array of values to create a vector.
|
* tf.tensor([1, 2, 3, 4]).print();
|
* ```
|
*
|
* ```js
|
* // Pass a nested array of values to make a matrix or a higher
|
* // dimensional tensor.
|
* tf.tensor([[1, 2], [3, 4]]).print();
|
* ```
|
*
|
* ```js
|
* // Pass a flat array and specify a shape yourself.
|
* tf.tensor([1, 2, 3, 4], [2, 2]).print();
|
* ```
|
*
|
* ```js
|
* // Pass a `WebGLData` object and specify a shape yourself.
|
*
|
* // This makes it possible for TF.js applications to avoid GPU / CPU sync.
|
* // For example, if your application includes a preprocessing step on the GPU,
|
* // you could upload the GPU output directly to TF.js, rather than first
|
* // downloading the values.
|
*
|
* // Example for WebGL2:
|
* if (tf.findBackend('custom-webgl') == null) {
|
* const customCanvas = document.createElement('canvas');
|
* const customBackend = new tf.MathBackendWebGL(customCanvas);
|
* tf.registerBackend('custom-webgl', () => customBackend);
|
* }
|
* const savedBackend = tf.getBackend();
|
* await tf.setBackend('custom-webgl');
|
* const gl = tf.backend().gpgpu.gl;
|
* const texture = gl.createTexture();
|
* const tex2d = gl.TEXTURE_2D;
|
* const width = 2;
|
* const height = 2;
|
*
|
* gl.bindTexture(tex2d, texture);
|
* gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
* gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
* gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
* gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
* gl.texImage2D(
|
* tex2d, 0, gl.RGBA32F, // internalFormat
|
* width, height, 0,
|
* gl.RGBA, // textureFormat
|
* gl.FLOAT, // textureType
|
* new Float32Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
|
* );
|
*
|
* // Currently, the `texture` has 4 pixels:
|
* // Pixel0 is {R:0, G:1, B:2, A:3}
|
* // Pixel1 is {R:4, G:5, B:6, A:7}
|
* // Pixel2 is {R:8, G:9, B:10, A:11}
|
* // Pixel3 is {R:12, G:13, B:14, A:15}
|
*
|
* const logicalShape = [height * width * 2];
|
* const a = tf.tensor({texture, height, width, channels: 'BR'}, logicalShape);
|
* a.print();
|
* // Tensor value will be [2, 0, 6, 4, 10, 8, 14, 12], since [2, 0] is the
|
* // values of 'B' and 'R' channels of Pixel0, [6, 4] is the values of 'B' and
|
* 'R'
|
* // channels of Pixel1...
|
*
|
* // For postprocessing on the GPU, it's possible to retrieve the texture
|
* // backing any tensor by calling the tensor's `dataToGPU` method like
|
* // so:
|
*
|
* const tex = a.dataToGPU();
|
* await tf.setBackend(savedBackend);
|
* ```
|
*
|
* ```js
|
* // Pass a `WebGPUData` object and specify a shape yourself.
|
*
|
* // This makes it possible for TF.js applications to avoid GPU / CPU sync.
|
* // For example, if your application includes a preprocessing step on the GPU,
|
* // you could upload the GPU output directly to TF.js, rather than first
|
* // downloading the values. Unlike WebGL, this optionally supports zero copy
|
* // by WebGPUData.zeroCopy. When zeroCopy is false or undefined(default), this
|
* // passing GPUBuffer can be destroyed after tensor is created. When zeroCopy
|
* // is true, this GPUBuffer is bound directly by the tensor, so do not destroy
|
* // this GPUBuffer until all access is done.
|
*
|
* // Example for WebGPU:
|
* function createGPUBufferFromData(device, data, dtype) {
|
* const bytesPerElement = 4;
|
* const sizeInBytes = data.length * bytesPerElement;
|
*
|
* const gpuWriteBuffer = device.createBuffer({
|
* mappedAtCreation: true,
|
* size: sizeInBytes,
|
* usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC
|
* });
|
* const arrayBuffer = gpuWriteBuffer.getMappedRange();
|
* if (dtype === 'float32') {
|
* new Float32Array(arrayBuffer).set(data);
|
* } else if (dtype === 'int32') {
|
* new Int32Array(arrayBuffer).set(data);
|
* } else {
|
* throw new Error(
|
* `Creating tensor from GPUBuffer only supports` +
|
* `'float32'|'int32' dtype, while the dtype is ${dtype}.`);
|
* }
|
* gpuWriteBuffer.unmap();
|
*
|
* const gpuReadBuffer = device.createBuffer({
|
* mappedAtCreation: false,
|
* size: sizeInBytes,
|
* usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE |
|
* GPUBufferUsage.COPY_SRC
|
* });
|
*
|
* const copyEncoder = device.createCommandEncoder();
|
* copyEncoder.copyBufferToBuffer(
|
* gpuWriteBuffer, 0, gpuReadBuffer, 0, sizeInBytes);
|
* const copyCommands = copyEncoder.finish();
|
* device.queue.submit([copyCommands]);
|
* gpuWriteBuffer.destroy();
|
* return gpuReadBuffer;
|
* }
|
*
|
* const savedBackend = tf.getBackend();
|
* await tf.setBackend('webgpu').catch(
|
* () => {throw new Error(
|
* 'Failed to use WebGPU backend. Please use Chrome Canary to run.')});
|
* const dtype = 'float32';
|
* const device = tf.backend().device;
|
* const aData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
|
* const bData = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4];
|
* const expected = [2, 4, 6, 8, 6, 8, 10, 12, 10, 12, 14, 16, 14, 16, 18, 20];
|
* const aBuffer = createGPUBufferFromData(device, aData, dtype);
|
* const shape = [aData.length];
|
* // To use zeroCopy, use {buffer: aBuffer, zeroCopy: true} instead and destroy
|
* // aBuffer untill all access is done.
|
* const a = tf.tensor({buffer: aBuffer}, shape, dtype);
|
* const b = tf.tensor(bData, shape, dtype);
|
* const result = tf.add(a, b);
|
* result.print();
|
* a.dispose();
|
* b.dispose();
|
* result.dispose();
|
* aBuffer.destroy();
|
* await tf.setBackend(savedBackend);
|
* ```
|
* @param values The values of the tensor. Can be nested array of numbers,
|
* or a flat array, or a `TypedArray`, or a `WebGLData` object, or a
|
* `WebGPUData` object. If the values are strings, they will be encoded as utf-8
|
* and kept as `Uint8Array[]`. If the values is a `WebGLData` object, the dtype
|
* could only be 'float32' or 'int32' and the object has to have: 1. texture, a
|
* `WebGLTexture`, the texture must share the same `WebGLRenderingContext` with
|
* TFJS's WebGL backend (you could create a custom WebGL backend from your
|
* texture's canvas) and the internal texture format for the input texture must
|
* be floating point or normalized integer; 2. height, the height of the
|
* texture; 3. width, the width of the texture; 4. channels, a non-empty subset
|
* of 'RGBA', indicating the values of which channels will be passed to the
|
* tensor, such as 'R' or 'BR' (The order of the channels affect the order of
|
* tensor values. ). (If the values passed from texture is less than the tensor
|
* size, zeros will be padded at the rear.). If the values is a `WebGPUData`
|
* object, the dtype could only be 'float32' or 'int32 and the object has to
|
* have: buffer, a `GPUBuffer`. The buffer must: 1. share the same `GPUDevice`
|
* with TFJS's WebGPU backend; 2. buffer.usage should at least support
|
* GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC; 3. buffer.size should not
|
* be smaller than the byte size of tensor shape. WebGPUData optionally supports
|
* zero copy by flag zeroCopy. When zeroCopy is false or undefined(default),
|
* this passing GPUBuffer can be destroyed after tensor is created. When
|
* zeroCopy is true, this GPUBuffer is bound directly by the tensor, so do not
|
* destroy this GPUBuffer until all access is done.
|
* @param shape The shape of the tensor. Optional. If not provided,
|
* it is inferred from `values`.
|
* @param dtype The data type.
|
*
|
* @doc {heading: 'Tensors', subheading: 'Creation'}
|
*/
|
export function tensor(values, shape, dtype) {
|
const inferredShape = inferShape(values, dtype);
|
return makeTensor(values, shape, inferredShape, dtype);
|
}
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tensor.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/ops/tensor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAI9C,OAAO,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiLG;AACH,MAAM,UAAU,MAAM,CAClB,MAAuC,EAAE,KAAmB,EAC5D,KAAgB;IAClB,MAAM,aAAa,GAAG,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChD,OAAO,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,CAAc,CAAC;AACtE,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {Tensor} from '../tensor';\nimport {inferShape} from '../tensor_util_env';\nimport {TensorLike} from '../types';\nimport {DataType, Rank, ShapeMap, WebGLData, WebGPUData} from '../types';\n\nimport {makeTensor} from './tensor_ops_util';\n\n/**\n * Creates a `tf.Tensor` with the provided values, shape and dtype.\n *\n * ```js\n * // Pass an array of values to create a vector.\n * tf.tensor([1, 2, 3, 4]).print();\n * ```\n *\n * ```js\n * // Pass a nested array of values to make a matrix or a higher\n * // dimensional tensor.\n * tf.tensor([[1, 2], [3, 4]]).print();\n * ```\n *\n * ```js\n * // Pass a flat array and specify a shape yourself.\n * tf.tensor([1, 2, 3, 4], [2, 2]).print();\n * ```\n *\n * ```js\n * // Pass a `WebGLData` object and specify a shape yourself.\n *\n * // This makes it possible for TF.js applications to avoid GPU / CPU sync.\n * // For example, if your application includes a preprocessing step on the GPU,\n * // you could upload the GPU output directly to TF.js, rather than first\n * // downloading the values.\n *\n * // Example for WebGL2:\n * if (tf.findBackend('custom-webgl') == null) {\n *   const customCanvas = document.createElement('canvas');\n *   const customBackend = new tf.MathBackendWebGL(customCanvas);\n *   tf.registerBackend('custom-webgl', () => customBackend);\n * }\n * const savedBackend = tf.getBackend();\n * await tf.setBackend('custom-webgl');\n * const gl = tf.backend().gpgpu.gl;\n * const texture = gl.createTexture();\n * const tex2d = gl.TEXTURE_2D;\n * const width = 2;\n * const height = 2;\n *\n * gl.bindTexture(tex2d, texture);\n * gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n * gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n * gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n * gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n * gl.texImage2D(\n *   tex2d, 0, gl.RGBA32F, // internalFormat\n *   width, height, 0,\n *   gl.RGBA, // textureFormat\n *   gl.FLOAT, // textureType\n *   new Float32Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])\n * );\n *\n * // Currently, the `texture` has 4 pixels:\n * // Pixel0 is {R:0, G:1, B:2, A:3}\n * // Pixel1 is {R:4, G:5, B:6, A:7}\n * // Pixel2 is {R:8, G:9, B:10, A:11}\n * // Pixel3 is {R:12, G:13, B:14, A:15}\n *\n * const logicalShape = [height * width * 2];\n * const a = tf.tensor({texture, height, width, channels: 'BR'}, logicalShape);\n * a.print();\n * // Tensor value will be [2, 0, 6, 4, 10, 8, 14, 12], since [2, 0] is the\n * // values of 'B' and 'R' channels of Pixel0, [6, 4] is the values of 'B' and\n * 'R'\n * // channels of Pixel1...\n *\n * // For postprocessing on the GPU, it's possible to retrieve the texture\n * // backing any tensor by calling the tensor's `dataToGPU` method like\n * // so:\n *\n * const tex = a.dataToGPU();\n * await tf.setBackend(savedBackend);\n * ```\n *\n * ```js\n * // Pass a `WebGPUData` object and specify a shape yourself.\n *\n * // This makes it possible for TF.js applications to avoid GPU / CPU sync.\n * // For example, if your application includes a preprocessing step on the GPU,\n * // you could upload the GPU output directly to TF.js, rather than first\n * // downloading the values. Unlike WebGL, this optionally supports zero copy\n * // by WebGPUData.zeroCopy. When zeroCopy is false or undefined(default), this\n * // passing GPUBuffer can be destroyed after tensor is created. When zeroCopy\n * // is true, this GPUBuffer is bound directly by the tensor, so do not destroy\n * // this GPUBuffer until all access is done.\n *\n * // Example for WebGPU:\n * function createGPUBufferFromData(device, data, dtype) {\n *   const bytesPerElement = 4;\n *   const sizeInBytes = data.length * bytesPerElement;\n *\n *   const gpuWriteBuffer = device.createBuffer({\n *     mappedAtCreation: true,\n *     size: sizeInBytes,\n *     usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC\n *   });\n *   const arrayBuffer = gpuWriteBuffer.getMappedRange();\n *   if (dtype === 'float32') {\n *     new Float32Array(arrayBuffer).set(data);\n *   } else if (dtype === 'int32') {\n *     new Int32Array(arrayBuffer).set(data);\n *   } else {\n *     throw new Error(\n *         `Creating tensor from GPUBuffer only supports` +\n *         `'float32'|'int32' dtype, while the dtype is ${dtype}.`);\n *   }\n *   gpuWriteBuffer.unmap();\n *\n *   const gpuReadBuffer = device.createBuffer({\n *     mappedAtCreation: false,\n *     size: sizeInBytes,\n *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE |\n *         GPUBufferUsage.COPY_SRC\n *   });\n *\n *   const copyEncoder = device.createCommandEncoder();\n *   copyEncoder.copyBufferToBuffer(\n *       gpuWriteBuffer, 0, gpuReadBuffer, 0, sizeInBytes);\n *   const copyCommands = copyEncoder.finish();\n *   device.queue.submit([copyCommands]);\n *   gpuWriteBuffer.destroy();\n *   return gpuReadBuffer;\n * }\n *\n * const savedBackend = tf.getBackend();\n * await tf.setBackend('webgpu').catch(\n *     () => {throw new Error(\n *         'Failed to use WebGPU backend. Please use Chrome Canary to run.')});\n * const dtype = 'float32';\n * const device = tf.backend().device;\n * const aData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];\n * const bData = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4];\n * const expected = [2, 4, 6, 8, 6, 8, 10, 12, 10, 12, 14, 16, 14, 16, 18, 20];\n * const aBuffer = createGPUBufferFromData(device, aData, dtype);\n * const shape = [aData.length];\n * // To use zeroCopy, use {buffer: aBuffer, zeroCopy: true} instead and destroy\n * // aBuffer untill all access is done.\n * const a = tf.tensor({buffer: aBuffer}, shape, dtype);\n * const b = tf.tensor(bData, shape, dtype);\n * const result = tf.add(a, b);\n * result.print();\n * a.dispose();\n * b.dispose();\n * result.dispose();\n * aBuffer.destroy();\n * await tf.setBackend(savedBackend);\n * ```\n * @param values The values of the tensor. Can be nested array of numbers,\n *     or a flat array, or a `TypedArray`, or a `WebGLData` object, or a\n * `WebGPUData` object. If the values are strings, they will be encoded as utf-8\n * and kept as `Uint8Array[]`. If the values is a `WebGLData` object, the dtype\n * could only be 'float32' or 'int32' and the object has to have: 1. texture, a\n * `WebGLTexture`, the texture must share the same `WebGLRenderingContext` with\n * TFJS's WebGL backend (you could create a custom WebGL backend from your\n * texture's canvas) and the internal texture format for the input texture must\n * be floating point or normalized integer; 2. height, the height of the\n * texture; 3. width, the width of the texture; 4. channels, a non-empty subset\n * of 'RGBA', indicating the values of which channels will be passed to the\n * tensor, such as 'R' or 'BR' (The order of the channels affect the order of\n * tensor values. ). (If the values passed from texture is less than the tensor\n * size, zeros will be padded at the rear.). If the values is a `WebGPUData`\n * object, the dtype could only be 'float32' or 'int32 and the object has to\n * have: buffer, a `GPUBuffer`. The buffer must: 1. share the same `GPUDevice`\n * with TFJS's WebGPU backend; 2. buffer.usage should at least support\n * GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC; 3. buffer.size should not\n * be smaller than the byte size of tensor shape. WebGPUData optionally supports\n * zero copy by flag zeroCopy. When zeroCopy is false or undefined(default),\n * this passing GPUBuffer can be destroyed after tensor is created. When\n * zeroCopy is true, this GPUBuffer is bound directly by the tensor, so do not\n * destroy this GPUBuffer until all access is done.\n * @param shape The shape of the tensor. Optional. If not provided,\n *   it is inferred from `values`.\n * @param dtype The data type.\n *\n * @doc {heading: 'Tensors', subheading: 'Creation'}\n */\nexport function tensor<R extends Rank>(\n    values: TensorLike|WebGLData|WebGPUData, shape?: ShapeMap[R],\n    dtype?: DataType): Tensor<R> {\n  const inferredShape = inferShape(values, dtype);\n  return makeTensor(values, shape, inferredShape, dtype) as Tensor<R>;\n}\n"]}
|
