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