onnxruntime

webnn.d.ts
401 строка · 12.4 Кб
Перенос по словам
1
// Copyright (c) Microsoft Corporation. All rights reserved.
2
// Licensed under the MIT License.
3

4
interface NavigatorML {
5
  readonly ml: ML;
6
}
7
interface Navigator extends NavigatorML {}
8
interface WorkerNavigator extends NavigatorML {}
9
type MLDeviceType = 'cpu'|'gpu'|'npu';
10
type MLPowerPreference = 'default'|'high-performance'|'low-power';
11
interface MLContextOptions {
12
  deviceType?: MLDeviceType;
13
  powerPreference?: MLPowerPreference;
14
  numThreads?: number;
15
}
16
interface ML {
17
  createContext(options?: MLContextOptions): Promise<MLContext>;
18
  createContext(gpuDevice: GPUDevice): Promise<MLContext>;
19
}
20
type MLNamedArrayBufferViews = Record<string, ArrayBufferView>;
21
interface MLComputeResult {
22
  inputs?: MLNamedArrayBufferViews;
23
  outputs?: MLNamedArrayBufferViews;
24
}
25
interface MLContext {
26
  compute(graph: MLGraph, inputs: MLNamedArrayBufferViews, outputs: MLNamedArrayBufferViews): Promise<MLComputeResult>;
27
}
28
interface MLGraph {}
29
type MLInputOperandLayout = 'nchw'|'nhwc';
30
type MLOperandDataType = 'float32'|'float16'|'int32'|'uint32'|'int64'|'uint64'|'int8'|'uint8';
31
interface MLOperandDescriptor {
32
  dataType: MLOperandDataType;
33
  dimensions?: number[];
34
}
35
interface MLOperand {
36
  dataType(): MLOperandDataType;
37
  shape(): number[];
38
}
39
interface MLActivation {}
40
type MLNamedOperands = Record<string, MLOperand>;
41
interface MLGraphBuilder {
42
  // eslint-disable-next-line @typescript-eslint/no-misused-new
43
  new(context: MLContext): MLGraphBuilder;
44
  input(name: string, descriptor: MLOperandDescriptor): MLOperand;
45
  constant(descriptor: MLOperandDescriptor, bufferView: ArrayBufferView): MLOperand;
46
  constant(type: MLOperandDataType, value: number): MLOperand;
47
  build(outputs: MLNamedOperands): Promise<MLGraph>;
48
}
49
interface MLArgMinMaxOptions {
50
  axes?: number[];
51
  keepDimensions?: boolean;
52
  selectLastIndex?: boolean;
53
}
54
interface MLGraphBuilder {
55
  argMin(input: MLOperand, options?: MLArgMinMaxOptions): MLOperand;
56
  argMax(input: MLOperand, options?: MLArgMinMaxOptions): MLOperand;
57
}
58
interface MLBatchNormalizationOptions {
59
  scale?: MLOperand;
60
  bias?: MLOperand;
61
  axis?: number;
62
  epsilon?: number;
63
}
64
interface MLGraphBuilder {
65
  batchNormalization(input: MLOperand, mean: MLOperand, variance: MLOperand, options?: MLBatchNormalizationOptions):
66
      MLOperand;
67
}
68
interface MLGraphBuilder {
69
  cast(input: MLOperand, type: MLOperandDataType): MLOperand;
70
}
71
interface MLClampOptions {
72
  minValue?: number;
73
  maxValue?: number;
74
}
75
interface MLGraphBuilder {
76
  clamp(input: MLOperand, options?: MLClampOptions): MLOperand;
77
  clamp(options?: MLClampOptions): MLActivation;
78
}
79
interface MLGraphBuilder {
80
  concat(inputs: MLOperand[], axis: number): MLOperand;
81
}
82
type MLConv2dFilterOperandLayout = 'oihw'|'hwio'|'ohwi'|'ihwo';
83
interface MLConv2dOptions {
84
  padding?: number[];
85
  strides?: number[];
86
  dilations?: number[];
87
  groups?: number;
88
  inputLayout?: MLInputOperandLayout;
89
  filterLayout?: MLConv2dFilterOperandLayout;
90
  bias?: MLOperand;
91
}
92
interface MLGraphBuilder {
93
  conv2d(input: MLOperand, filter: MLOperand, options?: MLConv2dOptions): MLOperand;
94
}
95
type MLConvTranspose2dFilterOperandLayout = 'iohw'|'hwoi'|'ohwi';
96
interface MLConvTranspose2dOptions {
97
  padding?: number[];
98
  strides?: number[];
99
  dilations?: number[];
100
  outputPadding?: number[];
101
  outputSizes?: number[];
102
  groups?: number;
103
  inputLayout?: MLInputOperandLayout;
104
  filterLayout?: MLConvTranspose2dFilterOperandLayout;
105
  bias?: MLOperand;
106
}
107
interface MLGraphBuilder {
108
  convTranspose2d(input: MLOperand, filter: MLOperand, options?: MLConvTranspose2dOptions): MLOperand;
109
}
110
interface MLGraphBuilder {
111
  add(a: MLOperand, b: MLOperand): MLOperand;
112
  sub(a: MLOperand, b: MLOperand): MLOperand;
113
  mul(a: MLOperand, b: MLOperand): MLOperand;
114
  div(a: MLOperand, b: MLOperand): MLOperand;
115
  max(a: MLOperand, b: MLOperand): MLOperand;
116
  min(a: MLOperand, b: MLOperand): MLOperand;
117
  pow(a: MLOperand, b: MLOperand): MLOperand;
118
}
119
interface MLGraphBuilder {
120
  equal(a: MLOperand, b: MLOperand): MLOperand;
121
  greater(a: MLOperand, b: MLOperand): MLOperand;
122
  greaterOrEqual(a: MLOperand, b: MLOperand): MLOperand;
123
  lesser(a: MLOperand, b: MLOperand): MLOperand;
124
  lesserOrEqual(a: MLOperand, b: MLOperand): MLOperand;
125
  logicalNot(a: MLOperand): MLOperand;
126
}
127
interface MLGraphBuilder {
128
  abs(input: MLOperand): MLOperand;
129
  ceil(input: MLOperand): MLOperand;
130
  cos(input: MLOperand): MLOperand;
131
  erf(input: MLOperand): MLOperand;
132
  exp(input: MLOperand): MLOperand;
133
  floor(input: MLOperand): MLOperand;
134
  identity(input: MLOperand): MLOperand;
135
  log(input: MLOperand): MLOperand;
136
  neg(input: MLOperand): MLOperand;
137
  reciprocal(input: MLOperand): MLOperand;
138
  sin(input: MLOperand): MLOperand;
139
  sqrt(input: MLOperand): MLOperand;
140
  tan(input: MLOperand): MLOperand;
141
}
142
interface MLEluOptions {
143
  alpha?: number;
144
}
145
interface MLGraphBuilder {
146
  elu(input: MLOperand, options?: MLEluOptions): MLOperand;
147
  elu(options?: MLEluOptions): MLActivation;
148
}
149
interface MLGraphBuilder {
150
  expand(input: MLOperand, newShape: number[]): MLOperand;
151
}
152
interface MLGatherOptions {
153
  axis?: number;
154
}
155
interface MLGraphBuilder {
156
  gather(input: MLOperand, indices: MLOperand, options?: MLGatherOptions): MLOperand;
157
}
158
interface MLGraphBuilder {
159
  gelu(input: MLOperand): MLOperand;
160
  gelu(): MLActivation;
161
}
162
interface MLGemmOptions {
163
  c?: MLOperand;
164
  alpha?: number;
165
  beta?: number;
166
  aTranspose?: boolean;
167
  bTranspose?: boolean;
168
}
169
interface MLGraphBuilder {
170
  gemm(a: MLOperand, b: MLOperand, options?: MLGemmOptions): MLOperand;
171
}
172
type MLGruWeightLayout = 'zrn'|'rzn';
173
type MLRecurrentNetworkDirection = 'forward'|'backward'|'both';
174
interface MLGruOptions {
175
  bias?: MLOperand;
176
  recurrentBias?: MLOperand;
177
  initialHiddenState?: MLOperand;
178
  resetAfter?: boolean;
179
  returnSequence?: boolean;
180
  direction?: MLRecurrentNetworkDirection;
181
  layout?: MLGruWeightLayout;
182
  activations?: MLActivation[];
183
}
184
interface MLGraphBuilder {
185
  gru(input: MLOperand, weight: MLOperand, recurrentWeight: MLOperand, steps: number, hiddenSize: number,
186
      options?: MLGruOptions): MLOperand[];
187
}
188
interface MLGruCellOptions {
189
  bias?: MLOperand;
190
  recurrentBias?: MLOperand;
191
  resetAfter?: boolean;
192
  layout?: MLGruWeightLayout;
193
  activations?: MLActivation[];
194
}
195
interface MLGraphBuilder {
196
  gruCell(
197
      input: MLOperand, weight: MLOperand, recurrentWeight: MLOperand, hiddenState: MLOperand, hiddenSize: number,
198
      options?: MLGruCellOptions): MLOperand;
199
}
200
interface MLHardSigmoidOptions {
201
  alpha?: number;
202
  beta?: number;
203
}
204
interface MLGraphBuilder {
205
  hardSigmoid(input: MLOperand, options?: MLHardSigmoidOptions): MLOperand;
206
  hardSigmoid(options?: MLHardSigmoidOptions): MLActivation;
207
}
208
interface MLGraphBuilder {
209
  hardSwish(input: MLOperand): MLOperand;
210
  hardSwish(): MLActivation;
211
}
212
interface MLInstanceNormalizationOptions {
213
  scale?: MLOperand;
214
  bias?: MLOperand;
215
  epsilon?: number;
216
  layout?: MLInputOperandLayout;
217
}
218
interface MLGraphBuilder {
219
  instanceNormalization(input: MLOperand, options?: MLInstanceNormalizationOptions): MLOperand;
220
}
221
interface MLLayerNormalizationOptions {
222
  scale?: MLOperand;
223
  bias?: MLOperand;
224
  axes?: number[];
225
  epsilon?: number;
226
}
227
interface MLGraphBuilder {
228
  layerNormalization(input: MLOperand, options?: MLLayerNormalizationOptions): MLOperand;
229
}
230
interface MLLeakyReluOptions {
231
  alpha?: number;
232
}
233
interface MLGraphBuilder {
234
  leakyRelu(input: MLOperand, options?: MLLeakyReluOptions): MLOperand;
235
  leakyRelu(options?: MLLeakyReluOptions): MLActivation;
236
}
237
interface MLLinearOptions {
238
  alpha?: number;
239
  beta?: number;
240
}
241
interface MLGraphBuilder {
242
  linear(input: MLOperand, options?: MLLinearOptions): MLOperand;
243
  linear(options?: MLLinearOptions): MLActivation;
244
}
245
type MLLstmWeightLayout = 'iofg'|'ifgo';
246
interface MLLstmOptions {
247
  bias?: MLOperand;
248
  recurrentBias?: MLOperand;
249
  peepholeWeight?: MLOperand;
250
  initialHiddenState?: MLOperand;
251
  initialCellState?: MLOperand;
252
  returnSequence?: boolean;
253
  direction?: MLRecurrentNetworkDirection;
254
  layout?: MLLstmWeightLayout;
255
  activations?: MLActivation[];
256
}
257
interface MLGraphBuilder {
258
  lstm(
259
      input: MLOperand, weight: MLOperand, recurrentWeight: MLOperand, steps: number, hiddenSize: number,
260
      options?: MLLstmOptions): MLOperand[];
261
}
262
interface MLLstmCellOptions {
263
  bias?: MLOperand;
264
  recurrentBias?: MLOperand;
265
  peepholeWeight?: MLOperand;
266
  layout?: MLLstmWeightLayout;
267
  activations?: MLActivation[];
268
}
269
interface MLGraphBuilder {
270
  lstmCell(
271
      input: MLOperand, weight: MLOperand, recurrentWeight: MLOperand, hiddenState: MLOperand, cellState: MLOperand,
272
      hiddenSize: number, options?: MLLstmCellOptions): MLOperand[];
273
}
274
interface MLGraphBuilder {
275
  matmul(a: MLOperand, b: MLOperand): MLOperand;
276
}
277
type MLPaddingMode = 'constant'|'edge'|'reflection'|'symmetric';
278
interface MLPadOptions {
279
  mode?: MLPaddingMode;
280
  value?: number;
281
}
282
interface MLGraphBuilder {
283
  pad(input: MLOperand, beginningPadding: number[], endingPadding: number[], options?: MLPadOptions): MLOperand;
284
}
285
type MLRoundingType = 'floor'|'ceil';
286
interface MLPool2dOptions {
287
  windowDimensions?: number[];
288
  padding?: number[];
289
  strides?: number[];
290
  dilations?: number[];
291
  layout?: MLInputOperandLayout;
292
  roundingType?: MLRoundingType;
293
  outputSizes?: number[];
294
}
295
interface MLGraphBuilder {
296
  averagePool2d(input: MLOperand, options?: MLPool2dOptions): MLOperand;
297
  l2Pool2d(input: MLOperand, options?: MLPool2dOptions): MLOperand;
298
  maxPool2d(input: MLOperand, options?: MLPool2dOptions): MLOperand;
299
}
300
interface MLGraphBuilder {
301
  prelu(input: MLOperand, slope: MLOperand): MLOperand;
302
}
303
interface MLReduceOptions {
304
  axes?: number[];
305
  keepDimensions?: boolean;
306
}
307
interface MLGraphBuilder {
308
  reduceL1(input: MLOperand, options?: MLReduceOptions): MLOperand;
309
  reduceL2(input: MLOperand, options?: MLReduceOptions): MLOperand;
310
  reduceLogSum(input: MLOperand, options?: MLReduceOptions): MLOperand;
311
  reduceLogSumExp(input: MLOperand, options?: MLReduceOptions): MLOperand;
312
  reduceMax(input: MLOperand, options?: MLReduceOptions): MLOperand;
313
  reduceMean(input: MLOperand, options?: MLReduceOptions): MLOperand;
314
  reduceMin(input: MLOperand, options?: MLReduceOptions): MLOperand;
315
  reduceProduct(input: MLOperand, options?: MLReduceOptions): MLOperand;
316
  reduceSum(input: MLOperand, options?: MLReduceOptions): MLOperand;
317
  reduceSumSquare(input: MLOperand, options?: MLReduceOptions): MLOperand;
318
}
319
interface MLGraphBuilder {
320
  relu(input: MLOperand): MLOperand;
321
  relu(): MLActivation;
322
}
323
type MLInterpolationMode = 'nearest-neighbor'|'linear';
324
interface MLResample2dOptions {
325
  mode?: MLInterpolationMode;
326
  scales?: number[];
327
  sizes?: number[];
328
  axes?: number[];
329
}
330
interface MLGraphBuilder {
331
  resample2d(input: MLOperand, options?: MLResample2dOptions): MLOperand;
332
}
333
interface MLGraphBuilder {
334
  reshape(input: MLOperand, newShape: number[]): MLOperand;
335
}
336
interface MLGraphBuilder {
337
  sigmoid(input: MLOperand): MLOperand;
338
  sigmoid(): MLActivation;
339
}
340
interface MLGraphBuilder {
341
  slice(input: MLOperand, starts: number[], sizes: number[]): MLOperand;
342
}
343
interface MLGraphBuilder {
344
  softmax(input: MLOperand, axis: number): MLOperand;
345
  softmax(axis: number): MLActivation;
346
}
347
interface MLGraphBuilder {
348
  softplus(input: MLOperand): MLOperand;
349
  softplus(): MLActivation;
350
}
351
interface MLGraphBuilder {
352
  softsign(input: MLOperand): MLOperand;
353
  softsign(): MLActivation;
354
}
355
interface MLSplitOptions {
356
  axis?: number;
357
}
358
interface MLGraphBuilder {
359
  split(input: MLOperand, splits: number|number[], options?: MLSplitOptions): MLOperand[];
360
}
361
interface MLGraphBuilder {
362
  tanh(input: MLOperand): MLOperand;
363
  tanh(): MLActivation;
364
}
365
interface MLTransposeOptions {
366
  permutation?: number[];
367
}
368
interface MLGraphBuilder {
369
  transpose(input: MLOperand, options?: MLTransposeOptions): MLOperand;
370
}
371
interface MLTriangularOptions {
372
  upper?: boolean;
373
  diagonal?: number;
374
}
375
interface MLGraphBuilder {
376
  triangular(input: MLOperand, options?: MLTriangularOptions): MLOperand;
377
}
378
interface MLGraphBuilder {
379
  where(condition: MLOperand, input: MLOperand, other: MLOperand): MLOperand;
380
}
381

382
// Experimental MLBuffer interface
383

384
type MLSize64Out = number;
385
interface MLBuffer {
386
  readonly size: MLSize64Out;
387
  destroy(): void;
388
}
389
type MLSize64 = number;
390
interface MLBufferDescriptor {
391
  size: MLSize64;
392
}
393
type MLNamedBuffers = Record<string, MLBuffer>;
394
interface MLContext {
395
  createBuffer(descriptor: MLBufferDescriptor): MLBuffer;
396
  writeBuffer(
397
      dstBuffer: MLBuffer, srcData: ArrayBufferView|ArrayBuffer, srcElementOffset?: MLSize64,
398
      srcElementSize?: MLSize64): void;
399
  readBuffer(srcBuffer: MLBuffer): Promise<ArrayBuffer>;
400
  dispatch(graph: MLGraph, inputs: MLNamedBuffers, outputs: MLNamedBuffers): void;
401
}
402
onnxruntime

Использование cookies
