1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | import { NamedTensorInfoMap, TensorInfo } from './kernel_registry';
|
18 | import { ExplicitPadding } from './ops/conv_util';
|
19 | import { Activation } from './ops/fused_types';
|
20 | import { DataType, PixelData } from './types';
|
21 | export declare const Abs = "Abs";
|
22 | export declare type AbsInputs = UnaryInputs;
|
23 | export declare const Acos = "Acos";
|
24 | export declare type AcosInputs = UnaryInputs;
|
25 | export declare const Acosh = "Acosh";
|
26 | export declare type AcoshInputs = UnaryInputs;
|
27 | export declare const Add = "Add";
|
28 | export declare type AddInputs = BinaryInputs;
|
29 | export declare const AddN = "AddN";
|
30 | export declare type AddNInputs = TensorInfo[];
|
31 | export declare const All = "All";
|
32 | export declare type AllInputs = Pick<NamedTensorInfoMap, 'x'>;
|
33 | export interface AllAttrs {
|
34 | axis: number | number[];
|
35 | keepDims: boolean;
|
36 | }
|
37 | export declare const Any = "Any";
|
38 | export declare type AnyInputs = Pick<NamedTensorInfoMap, 'x'>;
|
39 | export interface AnyAttrs {
|
40 | axis: number | number[];
|
41 | keepDims: boolean;
|
42 | }
|
43 | export declare const ArgMax = "ArgMax";
|
44 | export declare type ArgMaxInputs = Pick<NamedTensorInfoMap, 'x'>;
|
45 | export interface ArgMaxAttrs {
|
46 | axis: number;
|
47 | }
|
48 | export declare const ArgMin = "ArgMin";
|
49 | export declare type ArgMinInputs = Pick<NamedTensorInfoMap, 'x'>;
|
50 | export interface ArgMinAttrs {
|
51 | axis: number;
|
52 | }
|
53 | export declare const Asin = "Asin";
|
54 | export declare type AsinInputs = UnaryInputs;
|
55 | export declare const Asinh = "Asinh";
|
56 | export declare type AsinhInputs = UnaryInputs;
|
57 | export declare const Atan = "Atan";
|
58 | export declare type AtanInputs = UnaryInputs;
|
59 | export declare const Atanh = "Atanh";
|
60 | export declare type AtanhInputs = UnaryInputs;
|
61 | export declare const Atan2 = "Atan2";
|
62 | export declare type Atan2Inputs = BinaryInputs;
|
63 | export declare const AvgPool = "AvgPool";
|
64 | export declare type AvgPoolInputs = Pick<NamedTensorInfoMap, 'x'>;
|
65 | export interface AvgPoolAttrs {
|
66 | filterSize: [number, number] | number;
|
67 | strides: [number, number] | number;
|
68 | pad: 'valid' | 'same' | number;
|
69 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
70 | }
|
71 | export declare const AvgPoolGrad = "AvgPoolGrad";
|
72 | export declare type AvgPoolGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input'>;
|
73 | export interface AvgPoolGradAttrs {
|
74 | filterSize: [number, number] | number;
|
75 | strides: [number, number] | number;
|
76 | pad: 'valid' | 'same' | number;
|
77 | }
|
78 | export declare const AvgPool3D = "AvgPool3D";
|
79 | export declare type AvgPool3DInputs = Pick<NamedTensorInfoMap, 'x'>;
|
80 | export interface AvgPool3DAttrs {
|
81 | filterSize: [number, number, number] | number;
|
82 | strides: [number, number, number] | number;
|
83 | pad: 'valid' | 'same' | number;
|
84 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
85 | dataFormat: 'NDHWC' | 'NCDHW';
|
86 | }
|
87 | export declare const AvgPool3DGrad = "AvgPool3DGrad";
|
88 | export declare type AvgPool3DGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input'>;
|
89 | export interface AvgPool3DGradAttrs {
|
90 | filterSize: [number, number, number] | number;
|
91 | strides: [number, number, number] | number;
|
92 | pad: 'valid' | 'same' | number;
|
93 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
94 | }
|
95 | export declare const BatchMatMul = "BatchMatMul";
|
96 | export declare type BatchMatMulInputs = Pick<NamedTensorInfoMap, 'a' | 'b'>;
|
97 | export interface BatchMatMulAttrs {
|
98 | transposeA: boolean;
|
99 | transposeB: boolean;
|
100 | }
|
101 | export declare const BatchToSpaceND = "BatchToSpaceND";
|
102 | export declare type BatchToSpaceNDInputs = Pick<NamedTensorInfoMap, 'x'>;
|
103 | export interface BatchToSpaceNDAttrs {
|
104 | blockShape: number[];
|
105 | crops: number[][];
|
106 | }
|
107 | export declare type BinaryInputs = Pick<NamedTensorInfoMap, 'a' | 'b'>;
|
108 | export declare const Bincount = "Bincount";
|
109 | export declare type BincountInputs = Pick<NamedTensorInfoMap, 'x' | 'weights'>;
|
110 | export interface BincountAttrs {
|
111 | size: number;
|
112 | }
|
113 | export declare const BroadcastTo = "BroadcastTo";
|
114 | export declare type BroadcastToInputs = Pick<NamedTensorInfoMap, 'x'>;
|
115 | export interface BroadCastToAttrs {
|
116 | shape: number[];
|
117 | inputShape: number[];
|
118 | }
|
119 | export declare const Cast = "Cast";
|
120 | export declare type CastInputs = UnaryInputs;
|
121 | export interface CastAttrs {
|
122 | dtype: DataType;
|
123 | }
|
124 | export declare const Ceil = "Ceil";
|
125 | export declare type CeilInputs = UnaryInputs;
|
126 | export declare const ClipByValue = "ClipByValue";
|
127 | export declare type ClipByValueInputs = UnaryInputs;
|
128 | export interface ClipByValueAttrs {
|
129 | clipValueMin: number;
|
130 | clipValueMax: number;
|
131 | }
|
132 | export declare const Complex = "Complex";
|
133 | export declare type ComplexInputs = Pick<NamedTensorInfoMap, 'real' | 'imag'>;
|
134 | export declare const ComplexAbs = "ComplexAbs";
|
135 | export declare type ComplexAbsInputs = UnaryInputs;
|
136 | export declare const Concat = "Concat";
|
137 | export declare type ConcatInputs = TensorInfo[];
|
138 | export interface ConcatAttrs {
|
139 | axis: number;
|
140 | }
|
141 | export declare const Conv2D = "Conv2D";
|
142 | export declare type Conv2DInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
|
143 | export interface Conv2DAttrs {
|
144 | strides: [number, number] | number;
|
145 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
146 | dataFormat: 'NHWC' | 'NCHW';
|
147 | dilations: [number, number] | number;
|
148 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
149 | }
|
150 | export declare const Conv2DBackpropFilter = "Conv2DBackpropFilter";
|
151 | export declare type Conv2DBackpropFilterInputs = Pick<NamedTensorInfoMap, 'x' | 'dy'>;
|
152 | export interface Conv2DBackpropFilterAttrs {
|
153 | strides: [number, number] | number;
|
154 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
155 | dataFormat: 'NHWC' | 'NCHW';
|
156 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
157 | filterShape: [number, number, number, number];
|
158 | }
|
159 | export declare const Conv2DBackpropInput = "Conv2DBackpropInput";
|
160 | export declare type Conv2DBackpropInputInputs = Pick<NamedTensorInfoMap, 'dy' | 'filter'>;
|
161 | export interface Conv2DBackpropInputAttrs {
|
162 | strides: [number, number] | number;
|
163 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
164 | dataFormat: 'NHWC' | 'NCHW';
|
165 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
166 | inputShape: [number, number, number, number];
|
167 | }
|
168 | export declare const Conv3D = "Conv3D";
|
169 | export declare type Conv3DInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
|
170 | export interface Conv3DAttrs {
|
171 | strides: [number, number, number] | number;
|
172 | pad: 'valid' | 'same';
|
173 | dataFormat: 'NDHWC' | 'NCDHW';
|
174 | dilations: [number, number, number] | number;
|
175 | }
|
176 | export declare const Conv3DBackpropFilterV2 = "Conv3DBackpropFilterV2";
|
177 | export declare type Conv3DBackpropFilterV2Inputs = Pick<NamedTensorInfoMap, 'x' | 'dy'>;
|
178 | export interface Conv3DBackpropFilterV2Attrs {
|
179 | strides: [number, number, number] | number;
|
180 | pad: 'valid' | 'same';
|
181 | filterShape: [number, number, number, number, number];
|
182 | }
|
183 | export declare const Conv3DBackpropInputV2 = "Conv3DBackpropInputV2";
|
184 | export declare type Conv3DBackpropInputV2Inputs = Pick<NamedTensorInfoMap, 'dy' | 'filter'>;
|
185 | export interface Conv3DBackpropInputV2Attrs {
|
186 | strides: [number, number, number] | number;
|
187 | pad: 'valid' | 'same';
|
188 | inputShape: [number, number, number, number, number];
|
189 | }
|
190 | export declare const Cos = "Cos";
|
191 | export declare type CosInputs = UnaryInputs;
|
192 | export declare const Cosh = "Cosh";
|
193 | export declare type CoshInputs = UnaryInputs;
|
194 | export declare const Cumsum = "Cumsum";
|
195 | export declare type CumsumInputs = Pick<NamedTensorInfoMap, 'x'>;
|
196 | export interface CumsumAttrs {
|
197 | axis: number;
|
198 | exclusive: boolean;
|
199 | reverse: boolean;
|
200 | }
|
201 | export declare const CropAndResize = "CropAndResize";
|
202 | export declare type CropAndResizeInputs = Pick<NamedTensorInfoMap, 'image' | 'boxes' | 'boxInd'>;
|
203 | export interface CropAndResizeAttrs {
|
204 | cropSize: [number, number];
|
205 | method: 'bilinear' | 'nearest';
|
206 | extrapolationValue: number;
|
207 | }
|
208 | export declare const DenseBincount = "DenseBincount";
|
209 | export declare type DenseBincountInputs = Pick<NamedTensorInfoMap, 'x' | 'weights'>;
|
210 | export interface DenseBincountAttrs {
|
211 | size: number;
|
212 | binaryOutput?: boolean;
|
213 | }
|
214 | export declare const DepthToSpace = "DepthToSpace";
|
215 | export declare type DepthToSpaceInputs = Pick<NamedTensorInfoMap, 'x'>;
|
216 | export interface DepthToSpaceAttrs {
|
217 | blockSize: number;
|
218 | dataFormat: 'NHWC' | 'NCHW';
|
219 | }
|
220 | export declare const DepthwiseConv2dNative = "DepthwiseConv2dNative";
|
221 | export declare type DepthwiseConv2dNativeInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
|
222 | export interface DepthwiseConv2dNativeAttrs {
|
223 | strides: [number, number] | number;
|
224 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
225 | dataFormat: 'NHWC' | 'NCHW';
|
226 | dilations: [number, number] | number;
|
227 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
228 | }
|
229 | export declare const DepthwiseConv2dNativeBackpropFilter = "DepthwiseConv2dNativeBackpropFilter";
|
230 | export declare type DepthwiseConv2dNativeBackpropFilterInputs = Pick<NamedTensorInfoMap, 'x' | 'dy'>;
|
231 | export interface DepthwiseConv2dNativeBackpropFilterAttrs {
|
232 | strides: [number, number] | number;
|
233 | dilations: [number, number] | number;
|
234 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
235 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
236 | filterShape: [number, number, number, number];
|
237 | }
|
238 | export declare const DepthwiseConv2dNativeBackpropInput = "DepthwiseConv2dNativeBackpropInput";
|
239 | export declare type DepthwiseConv2dNativeBackpropInputInputs = Pick<NamedTensorInfoMap, 'dy' | 'filter'>;
|
240 | export interface DepthwiseConv2dNativeBackpropInputAttrs {
|
241 | strides: [number, number] | number;
|
242 | dilations: [number, number] | number;
|
243 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
244 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
245 | inputShape: [number, number, number, number];
|
246 | }
|
247 | export declare const Diag = "Diag";
|
248 | export declare type DiagInputs = Pick<NamedTensorInfoMap, 'x'>;
|
249 | export declare const Dilation2D = "Dilation2D";
|
250 | export declare type Dilation2DInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
|
251 | export interface Dilation2DAttrs {
|
252 | strides: [number, number] | number;
|
253 | pad: 'valid' | 'same' | number;
|
254 | dilations: [number, number] | number;
|
255 | }
|
256 | export declare const Dilation2DBackpropInput = "Dilation2DBackpropInput";
|
257 | export declare type Dilation2DBackpropInputInputs = Pick<NamedTensorInfoMap, 'x' | 'filter' | 'dy'>;
|
258 | export declare const Dilation2DBackpropFilter = "Dilation2DBackpropFilter";
|
259 | export declare type Dilation2DBackpropFilterInputs = Pick<NamedTensorInfoMap, 'x' | 'filter' | 'dy'>;
|
260 | export declare const RealDiv = "RealDiv";
|
261 | export declare type RealDivInputs = BinaryInputs;
|
262 | export declare const Einsum = "Einsum";
|
263 | export declare type EinsumInputs = TensorInfo[];
|
264 | export interface EinsumAttrs {
|
265 | equation: string;
|
266 | }
|
267 | export declare const Elu = "Elu";
|
268 | export declare type EluInputs = Pick<NamedTensorInfoMap, 'x'>;
|
269 | export declare const EluGrad = "EluGrad";
|
270 | export declare type EluGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'y'>;
|
271 | export declare const Erf = "Erf";
|
272 | export declare type ErfInputs = UnaryInputs;
|
273 | export declare const Equal = "Equal";
|
274 | export declare type EqualInputs = BinaryInputs;
|
275 | export declare const Exp = "Exp";
|
276 | export declare type ExpInputs = UnaryInputs;
|
277 | export declare const ExpandDims = "ExpandDims";
|
278 | export declare type ExpandDimsInputs = Pick<NamedTensorInfoMap, 'input'>;
|
279 | export interface ExpandDimsAttrs {
|
280 | dim: number;
|
281 | }
|
282 | export declare const Expm1 = "Expm1";
|
283 | export declare type Expm1Inputs = UnaryInputs;
|
284 | export declare const FFT = "FFT";
|
285 | export declare type FFTInputs = Pick<NamedTensorInfoMap, 'input'>;
|
286 | export declare const Fill = "Fill";
|
287 | export interface FillAttrs {
|
288 | shape: number[];
|
289 | value: number | string;
|
290 | dtype: DataType;
|
291 | }
|
292 | export declare const FlipLeftRight = "FlipLeftRight";
|
293 | export declare type FlipLeftRightInputs = Pick<NamedTensorInfoMap, 'image'>;
|
294 | export declare const Floor = "Floor";
|
295 | export declare type FloorInputs = UnaryInputs;
|
296 | export declare const FloorDiv = "FloorDiv";
|
297 | export declare type FloorDivInputs = BinaryInputs;
|
298 | export declare const FusedBatchNorm = "FusedBatchNorm";
|
299 | export declare type FusedBatchNormInputs = Pick<NamedTensorInfoMap, 'x' | 'scale' | 'offset' | 'mean' | 'variance'>;
|
300 | export interface FusedBatchNormAttrs {
|
301 | varianceEpsilon: number;
|
302 | }
|
303 | export declare const GatherV2 = "GatherV2";
|
304 | export declare type GatherV2Inputs = Pick<NamedTensorInfoMap, 'x' | 'indices'>;
|
305 | export interface GatherV2Attrs {
|
306 | axis: number;
|
307 | batchDims: number;
|
308 | }
|
309 | export declare const GatherNd = "GatherNd";
|
310 | export declare type GatherNdInputs = Pick<NamedTensorInfoMap, 'params' | 'indices'>;
|
311 | export declare const Greater = "Greater";
|
312 | export declare type GreaterInputs = BinaryInputs;
|
313 | export declare const GreaterEqual = "GreaterEqual";
|
314 | export declare type GreaterEqualInputs = BinaryInputs;
|
315 | export declare const Identity = "Identity";
|
316 | export declare type IdentityInputs = Pick<NamedTensorInfoMap, 'x'>;
|
317 | export declare const IFFT = "IFFT";
|
318 | export declare type IFFTInputs = Pick<NamedTensorInfoMap, 'input'>;
|
319 | export declare const Imag = "Imag";
|
320 | export declare type ImagInputs = Pick<NamedTensorInfoMap, 'input'>;
|
321 | export declare const IsFinite = "IsFinite";
|
322 | export declare type IsFiniteInputs = UnaryInputs;
|
323 | export declare const IsInf = "IsInf";
|
324 | export declare type IsInfInputs = UnaryInputs;
|
325 | export declare const IsNan = "IsNan";
|
326 | export declare type IsNanInputs = UnaryInputs;
|
327 | export declare const LeakyRelu = "LeakyRelu";
|
328 | export declare type LeakyReluInputs = Pick<NamedTensorInfoMap, 'x'>;
|
329 | export interface LeakyReluAttrs {
|
330 | alpha: number;
|
331 | }
|
332 | export declare const Less = "Less";
|
333 | export declare type LessInputs = BinaryInputs;
|
334 | export declare const LessEqual = "LessEqual";
|
335 | export declare type LessEqualInputs = BinaryInputs;
|
336 | export declare const LinSpace = "LinSpace";
|
337 | export interface LinSpaceAttrs {
|
338 | start: number;
|
339 | stop: number;
|
340 | num: number;
|
341 | }
|
342 | export declare const Log = "Log";
|
343 | export declare type LogInputs = UnaryInputs;
|
344 | export declare const Log1p = "Log1p";
|
345 | export declare type Log1pInputs = UnaryInputs;
|
346 | export declare const LogicalAnd = "LogicalAnd";
|
347 | export declare type LogicalAndInputs = BinaryInputs;
|
348 | export declare const LogicalNot = "LogicalNot";
|
349 | export declare type LogicalNotInputs = Pick<NamedTensorInfoMap, 'x'>;
|
350 | export declare const LogicalOr = "LogicalOr";
|
351 | export declare type LogicalOrInputs = BinaryInputs;
|
352 | export declare const LogSoftmax = "LogSoftmax";
|
353 | export declare type LogSoftmaxInputs = Pick<NamedTensorInfoMap, 'logits'>;
|
354 | export interface LogSoftmaxAttrs {
|
355 | axis: number;
|
356 | }
|
357 | export declare const LRN = "LRN";
|
358 | export declare type LRNInputs = Pick<NamedTensorInfoMap, 'x'>;
|
359 | export interface LRNAttrs {
|
360 | depthRadius: number;
|
361 | bias: number;
|
362 | alpha: number;
|
363 | beta: number;
|
364 | }
|
365 | export declare const LRNGrad = "LRNGrad";
|
366 | export declare type LRNGradInputs = Pick<NamedTensorInfoMap, 'x' | 'y' | 'dy'>;
|
367 | export interface LRNGradAttrs {
|
368 | depthRadius: number;
|
369 | bias: number;
|
370 | alpha: number;
|
371 | beta: number;
|
372 | }
|
373 | export declare const Max = "Max";
|
374 | export declare type MaxInputs = Pick<NamedTensorInfoMap, 'x'>;
|
375 | export interface MaxAttrs {
|
376 | reductionIndices: number | number[];
|
377 | keepDims: boolean;
|
378 | }
|
379 | export declare const Maximum = "Maximum";
|
380 | export declare type MaximumInputs = BinaryInputs;
|
381 | export declare const MaxPool = "MaxPool";
|
382 | export declare type MaxPoolInputs = Pick<NamedTensorInfoMap, 'x'>;
|
383 | export interface MaxPoolAttrs {
|
384 | filterSize: [number, number] | number;
|
385 | strides: [number, number] | number;
|
386 | pad: 'valid' | 'same' | number;
|
387 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
388 | }
|
389 | export declare const MaxPoolGrad = "MaxPoolGrad";
|
390 | export declare type MaxPoolGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input' | 'output'>;
|
391 | export interface MaxPoolGradAttrs {
|
392 | filterSize: [number, number] | number;
|
393 | strides: [number, number] | number;
|
394 | pad: 'valid' | 'same' | number;
|
395 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
396 | }
|
397 | export declare const MaxPool3D = "MaxPool3D";
|
398 | export declare type MaxPool3DInputs = Pick<NamedTensorInfoMap, 'x'>;
|
399 | export interface MaxPool3DAttrs {
|
400 | filterSize: [number, number, number] | number;
|
401 | strides: [number, number, number] | number;
|
402 | pad: 'valid' | 'same' | number;
|
403 | dataFormat: 'NDHWC' | 'NCDHW';
|
404 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
405 | }
|
406 | export declare const MaxPool3DGrad = "MaxPool3DGrad";
|
407 | export declare type MaxPool3DGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input' | 'output'>;
|
408 | export interface MaxPool3DGradAttrs {
|
409 | filterSize: [number, number, number] | number;
|
410 | strides: [number, number, number] | number;
|
411 | pad: 'valid' | 'same' | number;
|
412 | dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
413 | }
|
414 | export declare const MaxPoolWithArgmax = "MaxPoolWithArgmax";
|
415 | export declare type MaxPoolWithArgmaxInputs = Pick<NamedTensorInfoMap, 'x'>;
|
416 | export interface MaxPoolWithArgmaxAttrs {
|
417 | filterSize: [number, number] | number;
|
418 | strides: [number, number] | number;
|
419 | pad: 'valid' | 'same' | number;
|
420 | includeBatchInIndex: boolean;
|
421 | }
|
422 | export declare const Mean = "Mean";
|
423 | export declare type MeanInputs = Pick<NamedTensorInfoMap, 'x'>;
|
424 | export interface MeanAttrs {
|
425 | axis: number | number[];
|
426 | keepDims: boolean;
|
427 | }
|
428 | export declare const Min = "Min";
|
429 | export declare type MinInputs = Pick<NamedTensorInfoMap, 'x'>;
|
430 | export interface MinAttrs {
|
431 | axis: number | number[];
|
432 | keepDims: boolean;
|
433 | }
|
434 | export declare const Minimum = "Minimum";
|
435 | export declare type MinimumInputs = BinaryInputs;
|
436 | export declare const MirrorPad = "MirrorPad";
|
437 | export declare type MirrorPadInputs = Pick<NamedTensorInfoMap, 'x'>;
|
438 | export interface MirrorPadAttrs {
|
439 | paddings: Array<[number, number]>;
|
440 | mode: 'reflect' | 'symmetric';
|
441 | }
|
442 | export declare const Mod = "Mod";
|
443 | export declare type ModInputs = BinaryInputs;
|
444 | export declare const Multinomial = "Multinomial";
|
445 | export declare type MultinomialInputs = Pick<NamedTensorInfoMap, 'logits'>;
|
446 | export interface MultinomialAttrs {
|
447 | numSamples: number;
|
448 | seed: number;
|
449 | normalized: boolean;
|
450 | }
|
451 | export declare const Multiply = "Multiply";
|
452 | export declare type MultiplyInputs = BinaryInputs;
|
453 | export declare const Neg = "Neg";
|
454 | export declare type NegInputs = UnaryInputs;
|
455 | export declare const NotEqual = "NotEqual";
|
456 | export declare type NotEqualInputs = BinaryInputs;
|
457 | export declare const NonMaxSuppressionV3 = "NonMaxSuppressionV3";
|
458 | export declare type NonMaxSuppressionV3Inputs = Pick<NamedTensorInfoMap, 'boxes' | 'scores'>;
|
459 | export interface NonMaxSuppressionV3Attrs {
|
460 | maxOutputSize: number;
|
461 | iouThreshold: number;
|
462 | scoreThreshold: number;
|
463 | }
|
464 | export declare const NonMaxSuppressionV4 = "NonMaxSuppressionV4";
|
465 | export declare type NonMaxSuppressionV4Inputs = Pick<NamedTensorInfoMap, 'boxes' | 'scores'>;
|
466 | export interface NonMaxSuppressionV4Attrs {
|
467 | maxOutputSize: number;
|
468 | iouThreshold: number;
|
469 | scoreThreshold: number;
|
470 | padToMaxOutputSize: boolean;
|
471 | }
|
472 | export declare const NonMaxSuppressionV5 = "NonMaxSuppressionV5";
|
473 | export declare type NonMaxSuppressionV5Inputs = Pick<NamedTensorInfoMap, 'boxes' | 'scores'>;
|
474 | export interface NonMaxSuppressionV5Attrs {
|
475 | maxOutputSize: number;
|
476 | iouThreshold: number;
|
477 | scoreThreshold: number;
|
478 | softNmsSigma: number;
|
479 | }
|
480 | export declare const OnesLike = "OnesLike";
|
481 | export declare type OnesLikeInputs = UnaryInputs;
|
482 | export declare const OneHot = "OneHot";
|
483 | export declare type OneHotInputs = Pick<NamedTensorInfoMap, 'indices'>;
|
484 | export interface OneHotAttrs {
|
485 | depth: number;
|
486 | onValue: number;
|
487 | offValue: number;
|
488 | }
|
489 | export declare const Pack = "Pack";
|
490 | export declare type PackInputs = TensorInfo[];
|
491 | export interface PackAttrs {
|
492 | axis: number;
|
493 | }
|
494 | export declare const PadV2 = "PadV2";
|
495 | export declare type PadV2Inputs = Pick<NamedTensorInfoMap, 'x'>;
|
496 | export interface PadV2Attrs {
|
497 | paddings: Array<[number, number]>;
|
498 | constantValue: number;
|
499 | }
|
500 | export declare const Pool = "Pool";
|
501 | export declare type PoolInputs = Pick<NamedTensorInfoMap, 'input'>;
|
502 | export declare const Pow = "Pow";
|
503 | export declare type PowInputs = BinaryInputs;
|
504 | export declare const Prelu = "Prelu";
|
505 | export declare type PreluInputs = Pick<NamedTensorInfoMap, 'x' | 'alpha'>;
|
506 | export declare const Prod = "Prod";
|
507 | export declare type ProdInputs = Pick<NamedTensorInfoMap, 'x'>;
|
508 | export interface ProdAttrs {
|
509 | axis: number | number[];
|
510 | keepDims: boolean;
|
511 | }
|
512 | export declare const Range = "Range";
|
513 | export interface RangeAttrs {
|
514 | start: number;
|
515 | stop: number;
|
516 | step: number;
|
517 | dtype: 'float32' | 'int32';
|
518 | }
|
519 | export declare const Real = "Real";
|
520 | export declare type RealInputs = Pick<NamedTensorInfoMap, 'input'>;
|
521 | export declare const Reciprocal = "Reciprocal";
|
522 | export declare type ReciprocalInputs = UnaryInputs;
|
523 | export declare const Relu = "Relu";
|
524 | export declare type ReluInputs = Pick<NamedTensorInfoMap, 'x'>;
|
525 | export declare const Reshape = "Reshape";
|
526 | export declare type ReshapeInputs = Pick<NamedTensorInfoMap, 'x'>;
|
527 | export interface ReshapeAttrs {
|
528 | shape: number[];
|
529 | }
|
530 | export declare const ResizeNearestNeighbor = "ResizeNearestNeighbor";
|
531 | export declare type ResizeNearestNeighborInputs = Pick<NamedTensorInfoMap, 'images'>;
|
532 | export interface ResizeNearestNeighborAttrs {
|
533 | alignCorners: boolean;
|
534 | halfPixelCenters: boolean;
|
535 | size: [number, number];
|
536 | }
|
537 | export declare const ResizeNearestNeighborGrad = "ResizeNearestNeighborGrad";
|
538 | export declare type ResizeNearestNeighborGradInputs = Pick<NamedTensorInfoMap, 'images' | 'dy'>;
|
539 | export declare type ResizeNearestNeighborGradAttrs = ResizeNearestNeighborAttrs;
|
540 | export declare const ResizeBilinear = "ResizeBilinear";
|
541 | export declare type ResizeBilinearInputs = Pick<NamedTensorInfoMap, 'images'>;
|
542 | export interface ResizeBilinearAttrs {
|
543 | alignCorners: boolean;
|
544 | halfPixelCenters: boolean;
|
545 | size: [number, number];
|
546 | }
|
547 | export declare const ResizeBilinearGrad = "ResizeBilinearGrad";
|
548 | export declare type ResizeBilinearGradInputs = Pick<NamedTensorInfoMap, 'images' | 'dy'>;
|
549 | export declare type ResizeBilinearGradAttrs = ResizeBilinearAttrs;
|
550 | export declare const Relu6 = "Relu6";
|
551 | export declare type Relu6Inputs = Pick<NamedTensorInfoMap, 'x'>;
|
552 | export declare const Reverse = "Reverse";
|
553 | export declare type ReverseInputs = Pick<NamedTensorInfoMap, 'x'>;
|
554 | export interface ReverseAttrs {
|
555 | dims: number | number[];
|
556 | }
|
557 | export declare const Round = "Round";
|
558 | export declare type RoundInputs = UnaryInputs;
|
559 | export declare const Rsqrt = "Rsqrt";
|
560 | export declare type RsqrtInputs = UnaryInputs;
|
561 | export declare const ScatterNd = "ScatterNd";
|
562 | export declare type ScatterNdInputs = Pick<NamedTensorInfoMap, 'indices' | 'updates'>;
|
563 | export interface ScatterNdAttrs {
|
564 | shape: number[];
|
565 | }
|
566 | export declare const Select = "Select";
|
567 | export declare type SelectInputs = Pick<NamedTensorInfoMap, 'condition' | 't' | 'e'>;
|
568 | export declare const Selu = "Selu";
|
569 | export declare type SeluInputs = Pick<NamedTensorInfoMap, 'x'>;
|
570 | export declare const Slice = "Slice";
|
571 | export declare type SliceInputs = Pick<NamedTensorInfoMap, 'x'>;
|
572 | export interface SliceAttrs {
|
573 | begin: number | number[];
|
574 | size: number | number[];
|
575 | }
|
576 | export declare const Sin = "Sin";
|
577 | export declare type SinInputs = UnaryInputs;
|
578 | export declare const Sinh = "Sinh";
|
579 | export declare type SinhInputs = UnaryInputs;
|
580 | export declare const Sign = "Sign";
|
581 | export declare type SignInputs = UnaryInputs;
|
582 | export declare const Sigmoid = "Sigmoid";
|
583 | export declare type SigmoidInputs = UnaryInputs;
|
584 | export declare const Softplus = "Softplus";
|
585 | export declare type SoftplusInputs = UnaryInputs;
|
586 | export declare const Sqrt = "Sqrt";
|
587 | export declare type SqrtInputs = UnaryInputs;
|
588 | export declare const Sum = "Sum";
|
589 | export declare type SumInputs = Pick<NamedTensorInfoMap, 'x'>;
|
590 | export interface SumAttrs {
|
591 | axis: number | number[];
|
592 | keepDims: boolean;
|
593 | }
|
594 | export declare const SpaceToBatchND = "SpaceToBatchND";
|
595 | export declare type SpaceToBatchNDInputs = Pick<NamedTensorInfoMap, 'x'>;
|
596 | export interface SpaceToBatchNDAttrs {
|
597 | blockShape: number[];
|
598 | paddings: number[][];
|
599 | }
|
600 | export declare const SplitV = "SplitV";
|
601 | export declare type SplitVInputs = Pick<NamedTensorInfoMap, 'x'>;
|
602 | export interface SplitVAttrs {
|
603 | numOrSizeSplits: number[] | number;
|
604 | axis: number;
|
605 | }
|
606 | export declare const Softmax = "Softmax";
|
607 | export declare type SoftmaxInputs = Pick<NamedTensorInfoMap, 'logits'>;
|
608 | export interface SoftmaxAttrs {
|
609 | dim: number;
|
610 | }
|
611 | export declare const SparseFillEmptyRows = "SparseFillEmptyRows";
|
612 | export declare type SparseFillEmptyRowsInputs = Pick<NamedTensorInfoMap, 'indices' | 'values' | 'denseShape' | 'defaultValue'>;
|
613 | export declare const SparseReshape = "SparseReshape";
|
614 | export declare type SparseReshapeInputs = Pick<NamedTensorInfoMap, 'inputIndices' | 'inputShape' | 'newShape'>;
|
615 | export declare const SparseSegmentMean = "SparseSegmentMean";
|
616 | export declare type SparseSegmentMeanInputs = Pick<NamedTensorInfoMap, 'data' | 'indices' | 'segmentIds'>;
|
617 | export declare const SparseSegmentSum = "SparseSegmentSum";
|
618 | export declare type SparseSegmentSumInputs = Pick<NamedTensorInfoMap, 'data' | 'indices' | 'segmentIds'>;
|
619 | export declare const SparseToDense = "SparseToDense";
|
620 | export declare type SparseToDenseInputs = Pick<NamedTensorInfoMap, 'sparseIndices' | 'sparseValues' | 'defaultValue'>;
|
621 | export interface SparseToDenseAttrs {
|
622 | outputShape: number[];
|
623 | }
|
624 | export declare const SquaredDifference = "SquaredDifference";
|
625 | export declare type SquaredDifferenceInputs = BinaryInputs;
|
626 | export declare const Square = "Square";
|
627 | export declare type SquareInputs = Pick<NamedTensorInfoMap, 'x'>;
|
628 | export declare const StridedSlice = "StridedSlice";
|
629 | export declare type StridedSliceInputs = Pick<NamedTensorInfoMap, 'x'>;
|
630 | export interface StridedSliceAttrs {
|
631 | begin: number[];
|
632 | end: number[];
|
633 | strides: number[];
|
634 | beginMask: number;
|
635 | endMask: number;
|
636 | ellipsisMask: number;
|
637 | newAxisMask: number;
|
638 | shrinkAxisMask: number;
|
639 | }
|
640 | export declare const StringNGrams = "StringNGrams";
|
641 | export declare type StringNGramsInputs = Pick<NamedTensorInfoMap, 'data' | 'dataSplits'>;
|
642 | export interface StringNGramsAttrs {
|
643 | separator: string;
|
644 | nGramWidths: number[];
|
645 | leftPad: string;
|
646 | rightPad: string;
|
647 | padWidth: number;
|
648 | preserveShortSequences: boolean;
|
649 | }
|
650 | export declare const StringSplit = "StringSplit";
|
651 | export declare type StringSplitInputs = Pick<NamedTensorInfoMap, 'input' | 'delimiter'>;
|
652 | export interface StringSplitAttrs {
|
653 | skipEmpty: boolean;
|
654 | }
|
655 | export declare const StringToHashBucketFast = "StringToHashBucketFast";
|
656 | export declare type StringToHashBucketFastInputs = Pick<NamedTensorInfoMap, 'input'>;
|
657 | export interface StringToHashBucketFastAttrs {
|
658 | numBuckets: number;
|
659 | }
|
660 | export declare const Sub = "Sub";
|
661 | export declare type SubInputs = BinaryInputs;
|
662 | export declare const Tan = "Tan";
|
663 | export declare type TanInputs = UnaryInputs;
|
664 | export declare const Tanh = "Tanh";
|
665 | export declare type TanhInputs = UnaryInputs;
|
666 | export declare const Tile = "Tile";
|
667 | export declare type TileInputs = Pick<NamedTensorInfoMap, 'x'>;
|
668 | export interface TileAttrs {
|
669 | reps: number[];
|
670 | }
|
671 | export declare const TopK = "TopK";
|
672 | export declare type TopKInputs = Pick<NamedTensorInfoMap, 'x'>;
|
673 | export interface TopKAttrs {
|
674 | k: number;
|
675 | sorted: boolean;
|
676 | }
|
677 | export declare const Transform = "Transform";
|
678 | export declare type TransformInputs = Pick<NamedTensorInfoMap, 'image' | 'transforms'>;
|
679 | export interface TransformAttrs {
|
680 | interpolation: 'nearest' | 'bilinear';
|
681 | fillMode: 'constant' | 'reflect' | 'wrap' | 'nearest';
|
682 | fillValue: number;
|
683 | outputShape?: [number, number];
|
684 | }
|
685 | export declare const Transpose = "Transpose";
|
686 | export declare type TransposeInputs = Pick<NamedTensorInfoMap, 'x'>;
|
687 | export interface TransposeAttrs {
|
688 | perm: number[];
|
689 | }
|
690 | export declare const Unique = "Unique";
|
691 | export declare type UniqueInputs = Pick<NamedTensorInfoMap, 'x'>;
|
692 | export interface UniqueAttrs {
|
693 | axis: number;
|
694 | }
|
695 | export declare type UnaryInputs = Pick<NamedTensorInfoMap, 'x'>;
|
696 | export declare const Unpack = "Unpack";
|
697 | export declare type UnpackInputs = Pick<NamedTensorInfoMap, 'value'>;
|
698 | export interface UnpackAttrs {
|
699 | axis: number;
|
700 | }
|
701 | export declare const UnsortedSegmentSum = "UnsortedSegmentSum";
|
702 | export declare type UnsortedSegmentSumInputs = Pick<NamedTensorInfoMap, 'x' | 'segmentIds'>;
|
703 | export interface UnsortedSegmentSumAttrs {
|
704 | numSegments: number;
|
705 | }
|
706 | export declare const ZerosLike = "ZerosLike";
|
707 | export declare type ZerosLikeInputs = UnaryInputs;
|
708 |
|
709 |
|
710 |
|
711 | export declare const Step = "Step";
|
712 | export declare type StepInputs = UnaryInputs;
|
713 | export interface StepAttrs {
|
714 | alpha: number;
|
715 | }
|
716 | export declare const FromPixels = "FromPixels";
|
717 | export interface FromPixelsInputs {
|
718 | pixels: PixelData | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap;
|
719 | }
|
720 | export interface FromPixelsAttrs {
|
721 | numChannels: number;
|
722 | }
|
723 | export declare const RotateWithOffset = "RotateWithOffset";
|
724 | export declare type RotateWithOffsetInputs = Pick<NamedTensorInfoMap, 'image'>;
|
725 | export interface RotateWithOffsetAttrs {
|
726 | radians: number;
|
727 | fillValue: number | [number, number, number];
|
728 | center: number | [number, number];
|
729 | }
|
730 | export declare const _FusedMatMul = "_FusedMatMul";
|
731 | export interface _FusedMatMulInputs extends NamedTensorInfoMap {
|
732 | a: TensorInfo;
|
733 | b: TensorInfo;
|
734 | bias?: TensorInfo;
|
735 | preluActivationWeights?: TensorInfo;
|
736 | }
|
737 | export interface _FusedMatMulAttrs {
|
738 | transposeA: boolean;
|
739 | transposeB: boolean;
|
740 | activation: Activation;
|
741 | leakyreluAlpha?: number;
|
742 | }
|
743 | export declare const FusedConv2D = "FusedConv2D";
|
744 | export interface FusedConv2DInputs extends NamedTensorInfoMap {
|
745 | x: TensorInfo;
|
746 | filter: TensorInfo;
|
747 | bias?: TensorInfo;
|
748 | preluActivationWeights?: TensorInfo;
|
749 | }
|
750 | export interface FusedConv2DAttrs {
|
751 | strides: [number, number] | number;
|
752 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
753 | dataFormat: 'NHWC' | 'NCHW';
|
754 | dilations: [number, number] | number;
|
755 | dimRoundingMode: 'floor' | 'round' | 'ceil';
|
756 | activation: Activation;
|
757 | leakyreluAlpha?: number;
|
758 | }
|
759 | export declare const FusedDepthwiseConv2D = "FusedDepthwiseConv2D";
|
760 | export interface FusedDepthwiseConv2DInputs extends NamedTensorInfoMap {
|
761 | x: TensorInfo;
|
762 | filter: TensorInfo;
|
763 | bias?: TensorInfo;
|
764 | preluActivationWeights?: TensorInfo;
|
765 | }
|
766 | export interface FusedDepthwiseConv2DAttrs {
|
767 | strides: [number, number] | number;
|
768 | pad: 'valid' | 'same' | number | ExplicitPadding;
|
769 | dataFormat: 'NHWC' | 'NCHW';
|
770 | dilations: [number, number] | number;
|
771 | dimRoundingMode: 'floor' | 'round' | 'ceil';
|
772 | activation: Activation;
|
773 | leakyreluAlpha?: number;
|
774 | }
|