/**
|
* @license
|
* Copyright 2017 Google Inc. 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 './flags_webgl';
|
import { MemoryInfo, TimingInfo } from '../../engine';
|
import { TensorInfo } from '../../kernel_registry';
|
import { Conv2DInfo, Conv3DInfo } from '../../ops/conv_util';
|
import { FusedBatchMatMulConfig, FusedConv2DConfig } from '../../ops/fused_util';
|
import { DataId, Scalar, Tensor, Tensor1D, Tensor2D, Tensor3D, Tensor4D, Tensor5D } from '../../tensor';
|
import { BackendValues, DataType, Rank, RecursiveArray, ShapeMap } from '../../types';
|
import { DataStorage, KernelBackend } from '../backend';
|
import { GPGPUContext } from './gpgpu_context';
|
import * as gpgpu_math from './gpgpu_math';
|
import { GPGPUProgram } from './gpgpu_math';
|
import { TextureData } from './tex_util';
|
import { TextureManager } from './texture_manager';
|
declare type KernelInfo = {
|
name: string;
|
query: Promise<number>;
|
};
|
export declare type TimerNode = RecursiveArray<KernelInfo> | KernelInfo;
|
export interface CPUTimerQuery {
|
startMs: number;
|
endMs?: number;
|
}
|
export interface WebGLMemoryInfo extends MemoryInfo {
|
numBytesInGPU: number;
|
unreliable: boolean;
|
}
|
export interface WebGLTimingInfo extends TimingInfo {
|
uploadWaitMs: number;
|
downloadWaitMs: number;
|
}
|
export declare function getBinaryCache(webGLVersion: number): {
|
[key: string]: gpgpu_math.GPGPUBinary;
|
};
|
export declare const MATMUL_SHARED_DIM_THRESHOLD = 1000;
|
export declare class MathBackendWebGL extends KernelBackend {
|
texData: DataStorage<TextureData>;
|
gpgpu: GPGPUContext;
|
private pendingRead;
|
private pendingDisposal;
|
private dataRefCount;
|
private numBytesInGPU;
|
private canvas;
|
private programTimersStack;
|
private activeTimers;
|
private uploadWaitMs;
|
private downloadWaitMs;
|
private cpuBackend;
|
private floatPrecisionValue;
|
private textureManager;
|
private binaryCache;
|
private gpgpuCreatedLocally;
|
private numMBBeforeWarning;
|
private warnedAboutMemory;
|
constructor(gpgpu?: GPGPUContext);
|
numDataIds(): number;
|
write(values: BackendValues, shape: number[], dtype: DataType): DataId;
|
move(dataId: DataId, values: BackendValues, shape: number[], dtype: DataType): void;
|
readSync(dataId: DataId): BackendValues;
|
read(dataId: DataId): Promise<BackendValues>;
|
private checkNumericalProblems;
|
private getValuesFromTexture;
|
time(f: () => void): Promise<WebGLTimingInfo>;
|
memory(): WebGLMemoryInfo;
|
private startTimer;
|
private endTimer;
|
private getQueryTime;
|
private pendingDeletes;
|
disposeData(dataId: DataId): void;
|
private releaseGPUData;
|
getTexture(dataId: DataId): WebGLTexture;
|
/**
|
* Returns internal information for the specific data bucket. Used in unit
|
* tests.
|
*/
|
getDataInfo(dataId: DataId): TextureData;
|
private getCPUBackend;
|
private shouldExecuteOnCPU;
|
getGPGPUContext(): GPGPUContext;
|
complex<T extends Tensor>(real: T, imag: T): T;
|
real<T extends Tensor>(input: T): T;
|
imag<T extends Tensor>(input: T): T;
|
slice<T extends Tensor>(x: T, begin: number[], size: number[]): T;
|
private shallowSlice;
|
stridedSlice<T extends Tensor>(x: T, begin: number[], end: number[], strides: number[]): T;
|
reverse<T extends Tensor>(x: T, axis: number[]): T;
|
concat(tensors: Tensor[], axis: number): Tensor;
|
neg<T extends Tensor>(x: T): T;
|
batchMatMul(a: Tensor3D, b: Tensor3D, transposeA: boolean, transposeB: boolean): Tensor3D;
|
fusedBatchMatMul({ a, b, transposeA, transposeB, bias, activation, preluActivationWeights }: FusedBatchMatMulConfig): Tensor3D;
|
multiply(a: Tensor, b: Tensor): Tensor;
|
batchNormalization(x: Tensor4D, mean: Tensor4D | Tensor1D, variance: Tensor4D | Tensor1D, varianceEpsilon: number, scale?: Tensor4D | Tensor1D, offset?: Tensor4D | Tensor1D): Tensor4D;
|
localResponseNormalization4D(x: Tensor4D, radius: number, bias: number, alpha: number, beta: number): Tensor4D;
|
LRNGrad(dy: Tensor4D, inputImage: Tensor4D, outputImage: Tensor4D, depthRadius: number, bias: number, alpha: number, beta: number): Tensor4D;
|
tile<T extends Tensor>(x: T, reps: number[]): T;
|
pad<T extends Tensor>(x: T, paddings: Array<[number, number]>, constantValue: number): T;
|
transpose<T extends Tensor>(x: T, perm: number[]): T;
|
gather<T extends Tensor>(x: T, indices: Tensor1D, axis: number): T;
|
batchToSpaceND<T extends Tensor>(x: T, blockShape: number[], crops: number[][]): T;
|
spaceToBatchND<T extends Tensor>(x: T, blockShape: number[], paddings: Array<[number, number]>): T;
|
private reduce;
|
private argReduce;
|
private argReducePacked;
|
sum(x: Tensor, axes: number[]): Tensor;
|
prod(x: Tensor, axes: number[]): Tensor;
|
unsortedSegmentSum<T extends Tensor>(x: T, segmentIds: Tensor1D, numSegments: number): Tensor;
|
private segOpCompute;
|
private argMinMaxReduce;
|
argMin(x: Tensor, axis: number): Tensor;
|
argMax(x: Tensor, axis: number): Tensor;
|
cumsum(x: Tensor, axis: number, exclusive: boolean, reverse: boolean): Tensor;
|
equal(a: Tensor, b: Tensor): Tensor;
|
notEqual(a: Tensor, b: Tensor): Tensor;
|
less(a: Tensor, b: Tensor): Tensor;
|
lessEqual(a: Tensor, b: Tensor): Tensor;
|
greater(a: Tensor, b: Tensor): Tensor;
|
greaterEqual(a: Tensor, b: Tensor): Tensor;
|
logicalNot<T extends Tensor>(x: T): T;
|
logicalAnd(a: Tensor, b: Tensor): Tensor;
|
logicalOr(a: Tensor, b: Tensor): Tensor;
|
select(condition: Tensor, a: Tensor, b: Tensor): Tensor;
|
where(condition: Tensor): Tensor2D;
|
topk<T extends Tensor>(x: T, k: number, sorted: boolean): [T, T];
|
min(x: Tensor, axes: number[]): Tensor;
|
minimum(a: Tensor, b: Tensor): Tensor;
|
mod(a: Tensor, b: Tensor): Tensor;
|
max(x: Tensor, axes: number[]): Tensor;
|
maximum(a: Tensor, b: Tensor): Tensor;
|
all(x: Tensor, axes: number[]): Tensor;
|
any(x: Tensor, axes: number[]): Tensor;
|
realDivide(a: Tensor, b: Tensor): Tensor;
|
floorDiv(a: Tensor, b: Tensor): Tensor;
|
add(a: Tensor, b: Tensor): Tensor;
|
private packedUnaryOp;
|
private packedBinaryOp;
|
/**
|
* Computes a complex binary operation that can be decomposed into a simple
|
* binary operation on both the real and imagary parts.
|
*/
|
private complexSeparableBinaryOp;
|
private makeComplexComponentTensorInfo;
|
addN<T extends Tensor>(tensors: T[]): T;
|
subtract(a: Tensor, b: Tensor): Tensor;
|
pow<T extends Tensor>(a: T, b: Tensor): T;
|
ceil<T extends Tensor>(x: T): T;
|
floor<T extends Tensor>(x: T): T;
|
sign<T extends Tensor>(x: T): T;
|
isNaN<T extends Tensor>(x: T): T;
|
isInf<T extends Tensor>(x: T): T;
|
isFinite<T extends Tensor>(x: T): T;
|
round<T extends Tensor>(x: T): T;
|
exp<T extends Tensor>(x: T): T;
|
expm1<T extends Tensor>(x: T): T;
|
softmax<T extends Tensor>(logits: T, dim: number): T;
|
log<T extends Tensor>(x: T): T;
|
log1p<T extends Tensor>(x: T): T;
|
sqrt<T extends Tensor>(x: T): T;
|
rsqrt<T extends Tensor>(x: T): T;
|
reciprocal<T extends Tensor>(x: T): T;
|
relu<T extends Tensor>(x: T): T;
|
relu6<T extends Tensor>(x: T): T;
|
prelu<T extends Tensor>(x: T, alpha: T): T;
|
elu<T extends Tensor>(x: T): T;
|
eluDer<T extends Tensor>(dy: T, y: T): T;
|
selu<T extends Tensor>(x: T): T;
|
int<T extends Tensor>(x: T): T;
|
clip<T extends Tensor>(x: T, min: number, max: number): T;
|
abs<T extends Tensor>(x: T): T;
|
complexAbs<T extends Tensor>(x: T): T;
|
sigmoid<T extends Tensor>(x: T): T;
|
softplus<T extends Tensor>(x: T): T;
|
sin<T extends Tensor>(x: T): T;
|
cos<T extends Tensor>(x: T): T;
|
tan<T extends Tensor>(x: T): T;
|
asin<T extends Tensor>(x: T): T;
|
acos<T extends Tensor>(x: T): T;
|
atan<T extends Tensor>(x: T): T;
|
atan2<T extends Tensor>(a: T, b: T): T;
|
sinh<T extends Tensor>(x: T): T;
|
cosh<T extends Tensor>(x: T): T;
|
tanh<T extends Tensor>(x: T): T;
|
asinh<T extends Tensor>(x: T): T;
|
acosh<T extends Tensor>(x: T): T;
|
atanh<T extends Tensor>(x: T): T;
|
erf<T extends Tensor>(x: T): T;
|
step<T extends Tensor>(x: T, alpha: number): T;
|
private conv2dByMatMul;
|
private conv2dWithIm2Row;
|
fusedConv2d({ input, filter, convInfo, bias, activation, preluActivationWeights }: FusedConv2DConfig): Tensor4D;
|
conv2d(x: Tensor4D, filter: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
conv2dDerInput(dy: Tensor4D, filter: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
conv2dDerFilter(x: Tensor4D, dy: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
fusedDepthwiseConv2D({ input, filter, convInfo, bias, activation, preluActivationWeights }: FusedConv2DConfig): Tensor4D;
|
depthwiseConv2D(x: Tensor4D, filter: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
depthwiseConv2DDerInput(dy: Tensor4D, filter: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
depthwiseConv2DDerFilter(x: Tensor4D, dy: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
conv3d(x: Tensor5D, filter: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
conv3dDerInput(dy: Tensor5D, filter: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
conv3dDerFilter(x: Tensor5D, dy: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
maxPool(x: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
avgPool(x: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
maxPoolBackprop(dy: Tensor4D, x: Tensor4D, y: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
avgPoolBackprop(dy: Tensor4D, x: Tensor4D, convInfo: Conv2DInfo): Tensor4D;
|
cast<T extends Tensor>(x: T, dtype: DataType): T;
|
unstack(x: Tensor, axis: number): Tensor[];
|
avgPool3d(x: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
avgPool3dBackprop(dy: Tensor5D, x: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
maxPool3d(x: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
maxPool3dBackprop(dy: Tensor5D, x: Tensor5D, y: Tensor5D, convInfo: Conv3DInfo): Tensor5D;
|
reshape<R extends Rank>(x: Tensor, shape: ShapeMap[R]): Tensor<R>;
|
resizeBilinear(x: Tensor4D, newHeight: number, newWidth: number, alignCorners: boolean): Tensor4D;
|
resizeBilinearBackprop(dy: Tensor4D, x: Tensor4D, alignCorners: boolean): Tensor4D;
|
resizeNearestNeighbor(x: Tensor4D, newHeight: number, newWidth: number, alignCorners: boolean): Tensor4D;
|
resizeNearestNeighborBackprop(dy: Tensor4D, x: Tensor4D, alignCorners: boolean): Tensor4D;
|
multinomial(logits: Tensor2D, normalized: boolean, numSamples: number, seed: number): Tensor2D;
|
oneHot(indices: Tensor1D, depth: number, onValue: number, offValue: number): Tensor2D;
|
diag(x: Tensor): Tensor;
|
nonMaxSuppression(boxes: Tensor2D, scores: Tensor1D, maxOutputSize: number, iouThreshold: number, scoreThreshold: number): Tensor1D;
|
cropAndResize(image: Tensor4D, boxes: Tensor2D, boxIndex: Tensor1D, cropSize: [number, number], method: 'bilinear' | 'nearest', extrapolationValue: number): Tensor4D;
|
depthToSpace(x: Tensor4D, blockSize: number, dataFormat: 'NHWC' | 'NCHW'): Tensor4D;
|
split<T extends Tensor>(x: T, sizeSplits: number[], axis: number): T[];
|
scatterND<R extends Rank>(indices: Tensor, updates: Tensor, shape: ShapeMap[R]): Tensor<R>;
|
sparseToDense<R extends Rank>(sparseIndices: Tensor, sparseValues: Tensor, outputShape: ShapeMap[R], defaultValue: Scalar): Tensor<R>;
|
fft(x: Tensor2D): Tensor2D;
|
ifft(x: Tensor2D): Tensor2D;
|
private fftImpl;
|
gatherND(x: Tensor, indices: Tensor): Tensor;
|
fill<R extends Rank>(shape: ShapeMap[R], value: number | string, dtype?: DataType): Tensor<R>;
|
onesLike<R extends Rank>(x: Tensor<R>): Tensor<R>;
|
zerosLike<R extends Rank>(x: Tensor<R>): Tensor<R>;
|
linspace(start: number, stop: number, num: number): Tensor1D;
|
makeTensorInfo(shape: number[], dtype: DataType): TensorInfo;
|
private makeOutput;
|
private unpackTensor;
|
private packTensor;
|
private packedReshape;
|
private decode;
|
runWebGLProgram(program: GPGPUProgram, inputs: TensorInfo[], outputDtype: DataType, customSetup?: (gpgpu: GPGPUContext, webGLProgram: WebGLProgram) => void, preventEagerUnpackingOfOutput?: boolean): TensorInfo;
|
compileAndRun<K extends TensorInfo>(program: GPGPUProgram, inputs: TensorInfo[], outputDtype?: DataType, customSetup?: (gpgpu: GPGPUContext, webGLProgram: WebGLProgram) => void, preventEagerUnpackingOfOutput?: boolean): K;
|
private getAndSaveBinary;
|
getTextureManager(): TextureManager;
|
private disposed;
|
dispose(): void;
|
floatPrecision(): 16 | 32;
|
/** Returns the smallest representable number. */
|
epsilon(): number;
|
private uploadToGPU;
|
private convertAndCacheOnCPU;
|
private acquireTexture;
|
private computeBytes;
|
}
|
export {};
|
