Method LEGACY_deserialize

source/python.js:14194–14255

()

                return convertObject(obj);
            }
            LEGACY_deserialize() {
                // https://github.com/pytorch/pytorch/blob/5e69e11d098a2cfccc8a59377c431e9c71cab9a8/torch/csrc/jit/serialization/import_legacy.cpp#L88
                const execution = this._compilation_unit.execution;
                const caffe2 = execution.proto.caffe2;
                const torch = execution.import('torch');
                const stream = this._reader.get_record('model.json');
                const buffer = stream.peek();
                const decoder = new TextDecoder('utf-8');
                const content = decoder.decode(buffer);
                const obj = JSON.parse(content);
                const model = execution.proto.torch.ModelDef.decodeJson(obj);
                const tensorTypeMap = new Map([
                    [caffe2.TensorProto.DataType.FLOAT, 'Float'],
                    [caffe2.TensorProto.DataType.FLOAT16, 'Half'],
                    [caffe2.TensorProto.DataType.DOUBLE, 'Double'],
                    [caffe2.TensorProto.DataType.INT8, 'Char'],
                    [caffe2.TensorProto.DataType.INT32, 'Int'],
                    [caffe2.TensorProto.DataType.INT64, 'Long']
                ]);
                const tensor_table = (model.tensors || []).map((constant) => {
                    const key = constant.data.key;
                    if (!tensorTypeMap.has(constant.data_type)) {
                        throw new python.Error(`Unsupported tensor data type '${constant.data_type}'.`);
                    }
                    const type = tensorTypeMap.get(constant.data_type);
                    const shape = constant.dims ? constant.dims.map((dim) => parseInt(dim, 10)) : null;
                    const strides = constant.strides ? constant.strides.map((dim) => parseInt(dim, 10)) : null;
                    const storage_type = execution.resolve(`torch.${type}Storage`);
                    const size = (shape || []).reduce((a, b) => a * b, 1);
                    const offset = parseInt(constant.offset, 10) || 0;
                    const storage = new storage_type(size);
                    const itemsize = storage.dtype.itemsize();
                    const stream = this._reader.get_record(key);
                    if (stream) {
                        const buffer = stream.peek();
                        const length = size * itemsize;
                        const data = buffer.slice(offset, offset + length);
                        storage._set_cdata(data);
                    }
                    const tensor = torch._utils._rebuild_tensor(storage, 0, shape, strides);
                    tensor.name = key;
                    return tensor;
                });
                execution.builtins.CONSTANTS = {};
                for (let i = 0; i < tensor_table.length; i++) {
                    execution.builtins.CONSTANTS[`c${i}`] = tensor_table[i];
                }
                const attributes = [];
                if (this._reader.has_record('attributes.pkl')) {
                    const stream = this._reader.get_record('attributes.pkl');
                    const buffer = stream.peek();
                    const unpickler = new pickle.Unpickler(buffer);
                    const obj = unpickler.load();
                    attributes.push(...obj);
                }
                this._LEGACY_moduleStack = ['__torch__'];
                const module_def = model.main_module;
                for (const tensor of tensor_table) {