onnxruntime
Version:
Node.js binding of ONNXRuntime
232 lines • 9.54 kB
JavaScript
;
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var _session;
Object.defineProperty(exports, "__esModule", { value: true });
exports.impl = void 0;
const binding_1 = require("./binding");
const tensor_1 = require("./tensor");
class InferenceSession {
constructor(session) {
_session.set(this, void 0);
__classPrivateFieldSet(this, _session, session);
// cache metadata
this.inputNames = __classPrivateFieldGet(this, _session).inputNames;
this.outputNames = __classPrivateFieldGet(this, _session).outputNames;
}
run(feeds, arg1, arg2) {
const fetches = {};
let options = {};
// check inputs
if (typeof feeds !== 'object' || feeds === null || feeds instanceof tensor_1.Tensor || Array.isArray(feeds)) {
throw new TypeError('\'feeds\' must be an object that use input names as keys and OnnxValue as corresponding values.');
}
let isFetchesEmpty = true;
// determine which override is being used
if (typeof arg1 === 'object') {
if (arg1 === null) {
throw new TypeError('Unexpected argument[1]: cannot be null.');
}
if (arg1 instanceof tensor_1.Tensor) {
throw new TypeError('\'fetches\' cannot be a Tensor');
}
if (Array.isArray(arg1)) {
if (arg1.length === 0) {
throw new TypeError('\'fetches\' cannot be an empty array.');
}
isFetchesEmpty = false;
// output names
for (const name of arg1) {
if (typeof name !== 'string') {
throw new TypeError('\'fetches\' must be a string array or an object.');
}
if (this.outputNames.indexOf(name) === -1) {
throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
}
fetches[name] = null;
}
if (typeof arg2 === 'object' && arg2 !== null) {
options = arg2;
}
else if (typeof arg2 !== 'undefined') {
throw new TypeError('\'options\' must be an object.');
}
}
else {
// decide whether arg1 is fetches or options
// if any output name is present and its value is valid OnnxValue, we consider it fetches
let isFetches = false;
const arg1Keys = Object.getOwnPropertyNames(arg1);
for (const name of this.outputNames) {
if (arg1Keys.indexOf(name) !== -1) {
const v = arg1[name];
if (v === null || v instanceof tensor_1.Tensor) {
isFetches = true;
isFetchesEmpty = false;
fetches[name] = v;
}
}
}
if (isFetches) {
if (typeof arg2 === 'object' && arg2 !== null) {
options = arg2;
}
else if (typeof arg2 !== 'undefined') {
throw new TypeError('\'options\' must be an object.');
}
}
else {
options = arg1;
}
}
}
else if (typeof arg1 !== 'undefined') {
throw new TypeError('Unexpected argument[1]: must be \'fetches\' or \'options\'.');
}
// check if all inputs are in feed
for (const name of this.inputNames) {
if (typeof feeds[name] === 'undefined') {
throw new Error(`input '${name}' is missing in 'feeds'.`);
}
}
// if no fetches is specified, we use the full output names list
if (isFetchesEmpty) {
for (const name of this.outputNames) {
fetches[name] = null;
}
}
// feeds, fetches and options are prepared
// promise start here
//
//
return new Promise((resolve, reject) => {
process.nextTick(() => {
try {
const returnValue = {};
const results = __classPrivateFieldGet(this, _session).run(feeds, fetches, options);
for (const key in results) {
returnValue[key] = new tensor_1.Tensor(results[key].type, results[key].data, results[key].dims);
}
resolve(returnValue);
}
catch (e) {
// reject if any error is thrown
reject(e);
}
});
});
}
}
_session = new WeakMap();
exports.impl = {
create: (arg0, arg1, arg2, arg3) => {
// either load from a file or buffer
let loadFromFilePath = false;
let filePath;
let buffer;
let byteOffset = -1;
let byteLength = -1;
let options = {};
if (typeof arg0 === 'string') {
loadFromFilePath = true;
filePath = arg0;
if (typeof arg1 === 'object' && arg1 !== null) {
options = arg1;
}
else if (typeof arg1 !== 'undefined') {
throw new TypeError('\'options\' must be an object.');
}
}
else if (arg0 instanceof Uint8Array) {
buffer = arg0.buffer;
byteOffset = arg0.byteOffset;
byteLength = arg0.byteLength;
if (typeof arg1 === 'object' && arg1 !== null) {
options = arg1;
}
else if (typeof arg1 !== 'undefined') {
throw new TypeError('\'options\' must be an object.');
}
}
else if (arg0 instanceof ArrayBuffer || arg0 instanceof SharedArrayBuffer) {
buffer = arg0;
byteOffset = 0;
byteLength = arg0.byteLength;
if (typeof arg1 === 'object' && arg1 !== null) {
options = arg1;
}
else if (typeof arg1 === 'number') {
byteOffset = arg1;
if (!Number.isSafeInteger(byteOffset)) {
throw new RangeError('\'byteOffset\' must be an integer.');
}
if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
}
byteLength = arg0.byteLength - byteOffset;
if (typeof arg2 === 'number') {
byteLength = arg2;
if (!Number.isSafeInteger(byteLength)) {
throw new RangeError('\'byteLength\' must be an integer.');
}
if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
}
if (typeof arg3 === 'object' && arg3 !== null) {
options = arg3;
}
else if (typeof arg3 !== 'undefined') {
throw new TypeError('\'options\' must be an object.');
}
}
else if (typeof arg2 !== 'undefined') {
throw new TypeError('\'byteLength\' must be a number.');
}
}
else if (typeof arg1 !== 'undefined') {
throw new TypeError('\'options\' must be an object.');
}
}
else {
throw new TypeError('Unexpected argument[0]: must be \'path\' or \'buffer\'.');
}
// promise start here
//
//
return new Promise((resolve, reject) => {
process.nextTick(() => {
try {
// create native session wrapper
const sessionWrapper = new binding_1.binding.InferenceSession();
// load model
if (loadFromFilePath) {
sessionWrapper.loadModel(filePath, options);
}
else {
sessionWrapper.loadModel(buffer, byteOffset, byteLength, options);
}
// resolve promise if created successfully
resolve(new InferenceSession(sessionWrapper));
}
catch (e) {
// reject if any error is thrown
reject(e);
}
});
});
}
};
//# sourceMappingURL=inference-session-impl.js.map