1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
|
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: Web Neural Network API (https://webmachinelearning.github.io/webnn/)
interface mixin NavigatorML {
[SecureContext, SameObject] readonly attribute ML ml;
};
Navigator includes NavigatorML;
WorkerNavigator includes NavigatorML;
enum MLDeviceType {
"cpu",
"gpu"
};
enum MLPowerPreference {
"default",
"high-performance",
"low-power"
};
dictionary MLContextOptions {
MLDeviceType deviceType = "cpu";
MLPowerPreference powerPreference = "default";
};
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface ML {
Promise<MLContext> createContext(optional MLContextOptions options = {});
Promise<MLContext> createContext(GPUDevice gpuDevice);
[Exposed=(DedicatedWorker)]
MLContext createContextSync(optional MLContextOptions options = {});
[Exposed=(DedicatedWorker)]
MLContext createContextSync(GPUDevice gpuDevice);
};
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface MLActivation {
};
typedef (GPUBuffer or GPUTexture) MLGPUResource;
typedef record<DOMString, MLGPUResource> MLNamedGPUResources;
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface MLCommandEncoder {};
partial interface MLCommandEncoder {
undefined initializeGraph(MLGraph graph);
};
partial interface MLCommandEncoder {
undefined dispatch(MLGraph graph, MLNamedGPUResources inputs, MLNamedGPUResources outputs);
};
partial interface MLCommandEncoder {
GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
};
typedef record<DOMString, ArrayBufferView> MLNamedArrayBufferViews;
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface MLContext {};
partial interface MLContext {
[Exposed=(DedicatedWorker)]
undefined computeSync(
MLGraph graph, MLNamedArrayBufferViews inputs, MLNamedArrayBufferViews outputs);
};
dictionary MLComputeResult {
MLNamedArrayBufferViews inputs;
MLNamedArrayBufferViews outputs;
};
partial interface MLContext {
Promise<MLComputeResult> compute(
MLGraph graph, MLNamedArrayBufferViews inputs, MLNamedArrayBufferViews outputs);
};
partial interface MLContext {
MLCommandEncoder createCommandEncoder();
};
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface MLGraph {};
typedef record<DOMString, MLOperand> MLNamedOperands;
dictionary MLBufferResourceView {
required GPUBuffer resource;
unsigned long long offset = 0;
unsigned long long size;
};
typedef (ArrayBufferView or MLBufferResourceView) MLBufferView;
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface MLGraphBuilder {
// Construct the graph builder from the context.
constructor(MLContext context);
// Create an operand for a graph input.
MLOperand input(DOMString name, MLOperandDescriptor descriptor);
// Create an operand for a graph constant.
MLOperand constant(MLOperandDescriptor descriptor, MLBufferView bufferView);
// Create a single-value operand from the specified number of the specified type.
MLOperand constant(double value, optional MLOperandDataType type = "float32");
// Compile the graph up to the specified output operands asynchronously.
Promise<MLGraph> build(MLNamedOperands outputs);
// Compile the graph up to the specified output operands synchronously.
[Exposed=(DedicatedWorker)]
MLGraph buildSync(MLNamedOperands outputs);
};
dictionary MLArgMinMaxOptions {
sequence<unsigned long> axes = null;
boolean keepDimensions = false;
boolean selectLastIndex = false;
};
partial interface MLGraphBuilder {
MLOperand argMin(MLOperand input, optional MLArgMinMaxOptions options = {});
MLOperand argMax(MLOperand input, optional MLArgMinMaxOptions options = {});
};
dictionary MLBatchNormalizationOptions {
MLOperand scale;
MLOperand bias;
unsigned long axis = 1;
float epsilon = 1e-5;
MLActivation activation;
};
partial interface MLGraphBuilder {
MLOperand batchNormalization(MLOperand input, MLOperand mean, MLOperand variance,
optional MLBatchNormalizationOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand cast(MLOperand input, MLOperandDataType type);
};
dictionary MLClampOptions {
float minValue;
float maxValue;
};
partial interface MLGraphBuilder {
MLOperand clamp(MLOperand input, optional MLClampOptions options = {});
MLActivation clamp(optional MLClampOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand concat(sequence<MLOperand> inputs, unsigned long axis);
};
enum MLConv2dFilterOperandLayout {
"oihw",
"hwio",
"ohwi",
"ihwo"
};
enum MLAutoPad {
"explicit",
"same-upper",
"same-lower"
};
dictionary MLConv2dOptions {
sequence<unsigned long> padding;
sequence<unsigned long> strides;
sequence<unsigned long> dilations;
MLAutoPad autoPad = "explicit";
unsigned long groups = 1;
MLInputOperandLayout inputLayout = "nchw";
MLConv2dFilterOperandLayout filterLayout = "oihw";
MLOperand bias;
MLActivation activation;
};
partial interface MLGraphBuilder {
MLOperand conv2d(MLOperand input, MLOperand filter, optional MLConv2dOptions options = {});
};
enum MLConvTranspose2dFilterOperandLayout {
"iohw",
"hwoi",
"ohwi"
};
dictionary MLConvTranspose2dOptions {
sequence<unsigned long> padding;
sequence<unsigned long> strides;
sequence<unsigned long> dilations;
sequence<unsigned long> outputPadding;
sequence<unsigned long> outputSizes;
MLAutoPad autoPad = "explicit";
unsigned long groups = 1;
MLInputOperandLayout inputLayout = "nchw";
MLConvTranspose2dFilterOperandLayout filterLayout = "iohw";
MLOperand bias;
MLActivation activation;
};
partial interface MLGraphBuilder {
MLOperand convTranspose2d(MLOperand input, MLOperand filter,
optional MLConvTranspose2dOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand add(MLOperand a, MLOperand b);
MLOperand sub(MLOperand a, MLOperand b);
MLOperand mul(MLOperand a, MLOperand b);
MLOperand div(MLOperand a, MLOperand b);
MLOperand max(MLOperand a, MLOperand b);
MLOperand min(MLOperand a, MLOperand b);
MLOperand pow(MLOperand a, MLOperand b);
};
partial interface MLGraphBuilder {
MLOperand equal(MLOperand a, MLOperand b);
MLOperand greater(MLOperand a, MLOperand b);
MLOperand greaterOrEqual(MLOperand a, MLOperand b);
MLOperand lesser(MLOperand a, MLOperand b);
MLOperand lesserOrEqual(MLOperand a, MLOperand b);
MLOperand not(MLOperand a);
};
partial interface MLGraphBuilder {
MLOperand abs(MLOperand input);
MLOperand ceil(MLOperand input);
MLOperand cos(MLOperand input);
MLOperand erf(MLOperand input);
MLOperand exp(MLOperand input);
MLOperand floor(MLOperand input);
MLOperand identity(MLOperand input);
MLOperand log(MLOperand input);
MLOperand neg(MLOperand input);
MLOperand reciprocal(MLOperand input);
MLOperand sin(MLOperand input);
MLOperand sqrt(MLOperand input);
MLOperand tan(MLOperand input);
};
dictionary MLEluOptions {
float alpha = 1;
};
partial interface MLGraphBuilder {
MLOperand elu(MLOperand input, optional MLEluOptions options = {});
MLActivation elu(optional MLEluOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand expand(MLOperand input, sequence<unsigned long> newShape);
};
dictionary MLGatherOptions {
unsigned long axis = 0;
};
partial interface MLGraphBuilder {
MLOperand gather(MLOperand input, MLOperand indices, optional MLGatherOptions options = {});
};
dictionary MLGemmOptions {
MLOperand c;
float alpha = 1.0;
float beta = 1.0;
boolean aTranspose = false;
boolean bTranspose = false;
};
partial interface MLGraphBuilder {
MLOperand gemm(MLOperand a, MLOperand b, optional MLGemmOptions options = {});
};
enum MLGruWeightLayout {
"zrn", // update-reset-new gate ordering
"rzn" // reset-update-new gate ordering
};
enum MLRecurrentNetworkDirection {
"forward",
"backward",
"both"
};
dictionary MLGruOptions {
MLOperand bias;
MLOperand recurrentBias;
MLOperand initialHiddenState;
boolean resetAfter = true;
boolean returnSequence = false;
MLRecurrentNetworkDirection direction = "forward";
MLGruWeightLayout layout = "zrn";
sequence<MLActivation> activations;
};
partial interface MLGraphBuilder {
sequence<MLOperand> gru(MLOperand input, MLOperand weight, MLOperand recurrentWeight,
unsigned long steps, unsigned long hiddenSize,
optional MLGruOptions options = {});
};
dictionary MLGruCellOptions {
MLOperand bias;
MLOperand recurrentBias;
boolean resetAfter = true;
MLGruWeightLayout layout = "zrn";
sequence<MLActivation> activations;
};
partial interface MLGraphBuilder {
MLOperand gruCell(MLOperand input, MLOperand weight, MLOperand recurrentWeight,
MLOperand hiddenState, unsigned long hiddenSize,
optional MLGruCellOptions options = {});
};
dictionary MLHardSigmoidOptions {
float alpha = 0.2;
float beta = 0.5;
};
partial interface MLGraphBuilder {
MLOperand hardSigmoid(MLOperand input, optional MLHardSigmoidOptions options = {});
MLActivation hardSigmoid(optional MLHardSigmoidOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand hardSwish(MLOperand input);
MLActivation hardSwish();
};
dictionary MLInstanceNormalizationOptions {
MLOperand scale;
MLOperand bias;
float epsilon = 1e-5;
MLInputOperandLayout layout = "nchw";
};
partial interface MLGraphBuilder {
MLOperand instanceNormalization(MLOperand input,
optional MLInstanceNormalizationOptions options = {});
};
dictionary MLLayerNormalizationOptions {
MLOperand scale;
MLOperand bias;
sequence<unsigned long> axes;
float epsilon = 1e-5;
};
partial interface MLGraphBuilder {
MLOperand layerNormalization(MLOperand input, optional MLLayerNormalizationOptions options = {});
};
dictionary MLLeakyReluOptions {
float alpha = 0.01;
};
partial interface MLGraphBuilder {
MLOperand leakyRelu(MLOperand input, optional MLLeakyReluOptions options = {});
MLActivation leakyRelu(optional MLLeakyReluOptions options = {});
};
dictionary MLLinearOptions {
float alpha = 1;
float beta = 0;
};
partial interface MLGraphBuilder {
MLOperand linear(MLOperand input, optional MLLinearOptions options = {});
MLActivation linear(optional MLLinearOptions options = {});
};
enum MLLstmWeightLayout {
"iofg", // input-output-forget-cell gate ordering
"ifgo" // input-forget-cell-output gate ordering
};
dictionary MLLstmOptions {
MLOperand bias;
MLOperand recurrentBias;
MLOperand peepholeWeight;
MLOperand initialHiddenState;
MLOperand initialCellState;
boolean returnSequence = false;
MLRecurrentNetworkDirection direction = "forward";
MLLstmWeightLayout layout = "iofg";
sequence<MLActivation> activations;
};
partial interface MLGraphBuilder {
sequence<MLOperand> lstm(MLOperand input, MLOperand weight, MLOperand recurrentWeight,
unsigned long steps, unsigned long hiddenSize,
optional MLLstmOptions options = {});
};
dictionary MLLstmCellOptions {
MLOperand bias;
MLOperand recurrentBias;
MLOperand peepholeWeight;
MLLstmWeightLayout layout = "iofg";
sequence<MLActivation> activations;
};
partial interface MLGraphBuilder {
sequence<MLOperand> lstmCell(MLOperand input, MLOperand weight, MLOperand recurrentWeight,
MLOperand hiddenState, MLOperand cellState, unsigned long hiddenSize,
optional MLLstmCellOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand matmul(MLOperand a, MLOperand b);
};
enum MLPaddingMode {
"constant",
"edge",
"reflection",
"symmetric"
};
dictionary MLPadOptions {
MLPaddingMode mode = "constant";
float value = 0;
};
partial interface MLGraphBuilder {
MLOperand pad(MLOperand input,
sequence<unsigned long> beginningPadding,
sequence<unsigned long> endingPadding,
optional MLPadOptions options = {});
};
enum MLRoundingType {
"floor",
"ceil"
};
dictionary MLPool2dOptions {
sequence<unsigned long> windowDimensions;
sequence<unsigned long> padding;
sequence<unsigned long> strides;
sequence<unsigned long> dilations;
MLAutoPad autoPad = "explicit";
MLInputOperandLayout layout = "nchw";
MLRoundingType roundingType = "floor";
sequence<unsigned long> outputSizes;
};
partial interface MLGraphBuilder {
MLOperand averagePool2d(MLOperand input, optional MLPool2dOptions options = {});
MLOperand l2Pool2d(MLOperand input, optional MLPool2dOptions options = {});
MLOperand maxPool2d(MLOperand input, optional MLPool2dOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand prelu(MLOperand input, MLOperand slope);
};
dictionary MLReduceOptions {
sequence<unsigned long> axes = null;
boolean keepDimensions = false;
};
partial interface MLGraphBuilder {
MLOperand reduceL1(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceL2(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceLogSum(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceLogSumExp(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceMax(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceMean(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceMin(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceProduct(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceSum(MLOperand input, optional MLReduceOptions options = {});
MLOperand reduceSumSquare(MLOperand input, optional MLReduceOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand relu(MLOperand input);
MLActivation relu();
};
enum MLInterpolationMode {
"nearest-neighbor",
"linear"
};
dictionary MLResample2dOptions {
MLInterpolationMode mode = "nearest-neighbor";
sequence<float> scales;
sequence<unsigned long> sizes;
sequence<unsigned long> axes;
};
partial interface MLGraphBuilder {
MLOperand resample2d(MLOperand input, optional MLResample2dOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand reshape(MLOperand input, sequence<unsigned long> newShape);
};
partial interface MLGraphBuilder {
MLOperand sigmoid(MLOperand input);
MLActivation sigmoid();
};
partial interface MLGraphBuilder {
MLOperand slice(MLOperand input, sequence<unsigned long> starts, sequence<unsigned long> sizes);
};
partial interface MLGraphBuilder {
MLOperand softmax(MLOperand input);
MLActivation softmax();
};
dictionary MLSoftplusOptions {
float steepness = 1;
};
partial interface MLGraphBuilder {
MLOperand softplus(MLOperand input, optional MLSoftplusOptions options = {});
MLActivation softplus(optional MLSoftplusOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand softsign(MLOperand input);
MLActivation softsign();
};
dictionary MLSplitOptions {
unsigned long axis = 0;
};
partial interface MLGraphBuilder {
sequence<MLOperand> split(MLOperand input,
(unsigned long or sequence<unsigned long>) splits,
optional MLSplitOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand tanh(MLOperand input);
MLActivation tanh();
};
dictionary MLTransposeOptions {
sequence<unsigned long> permutation;
};
partial interface MLGraphBuilder {
MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
};
dictionary MLTriangularOptions {
boolean upper = true;
long diagonal = 0;
};
partial interface MLGraphBuilder {
MLOperand triangular(MLOperand input, optional MLTriangularOptions options = {});
};
partial interface MLGraphBuilder {
MLOperand where(MLOperand condition, MLOperand input, MLOperand other);
};
[SecureContext, Exposed=(Window, DedicatedWorker)]
interface MLOperand {};
partial interface MLOperand {
MLOperandDataType dataType();
};
partial interface MLOperand {
sequence<unsigned long> shape();
};
enum MLInputOperandLayout {
"nchw",
"nhwc"
};
enum MLOperandDataType {
"float32",
"float16",
"int32",
"uint32",
"int64",
"uint64",
"int8",
"uint8"
};
dictionary MLOperandDescriptor {
// The operand type.
required MLOperandDataType dataType;
// The dimensions field is only required for tensor operands.
sequence<unsigned long> dimensions;
};
|