Package org.nd4j.ir

Class TensorNamespace.TensorProto.Builder

    • Method Detail

      • getDescriptor

        public static final org.nd4j.shade.protobuf.Descriptors.Descriptor getDescriptor()

      • internalGetFieldAccessorTable

        protected org.nd4j.shade.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
        Specified by:
        internalGetFieldAccessorTable in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<TensorNamespace.TensorProto.Builder>

      • getDescriptorForType

        public org.nd4j.shade.protobuf.Descriptors.Descriptor getDescriptorForType()
        Specified by:
        getDescriptorForType in interface org.nd4j.shade.protobuf.Message.Builder
        Specified by:
        getDescriptorForType in interface org.nd4j.shade.protobuf.MessageOrBuilder
        Overrides:
        getDescriptorForType in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<TensorNamespace.TensorProto.Builder>

      • getDefaultInstanceForType

        public TensorNamespace.TensorProto getDefaultInstanceForType()
        Specified by:
        getDefaultInstanceForType in interface org.nd4j.shade.protobuf.MessageLiteOrBuilder
        Specified by:
        getDefaultInstanceForType in interface org.nd4j.shade.protobuf.MessageOrBuilder

      • build

        public TensorNamespace.TensorProto build()
        Specified by:
        build in interface org.nd4j.shade.protobuf.Message.Builder
        Specified by:
        build in interface org.nd4j.shade.protobuf.MessageLite.Builder

      • buildPartial

        public TensorNamespace.TensorProto buildPartial()
        Specified by:
        buildPartial in interface org.nd4j.shade.protobuf.Message.Builder
        Specified by:
        buildPartial in interface org.nd4j.shade.protobuf.MessageLite.Builder

      • setRepeatedField

        public TensorNamespace.TensorProto.Builder setRepeatedField​(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field,
                                                            int index,
                                                            Object value)
        Specified by:
        setRepeatedField in interface org.nd4j.shade.protobuf.Message.Builder
        Overrides:
        setRepeatedField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<TensorNamespace.TensorProto.Builder>

      • isInitialized

        public final boolean isInitialized()
        Specified by:
        isInitialized in interface org.nd4j.shade.protobuf.MessageLiteOrBuilder
        Overrides:
        isInitialized in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<TensorNamespace.TensorProto.Builder>

      • mergeFrom

        public TensorNamespace.TensorProto.Builder mergeFrom​(org.nd4j.shade.protobuf.CodedInputStream input,
                                                     org.nd4j.shade.protobuf.ExtensionRegistryLite extensionRegistry)
                                              throws IOException
        Specified by:
        mergeFrom in interface org.nd4j.shade.protobuf.Message.Builder
        Specified by:
        mergeFrom in interface org.nd4j.shade.protobuf.MessageLite.Builder
        Overrides:
        mergeFrom in class org.nd4j.shade.protobuf.AbstractMessage.Builder<TensorNamespace.TensorProto.Builder>
        Throws:
        IOException

      • getDims

        public long getDims​(int index)
         The shape of the tensor.
        repeated int64 dims = 1;
        Specified by:
        getDims in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The dims at the given index.

      • setDims

        public TensorNamespace.TensorProto.Builder setDims​(int index,
                                                   long value)
         The shape of the tensor.
        repeated int64 dims = 1;
        Parameters:
        index - The index to set the value at.
        value - The dims to set.
        Returns:
        This builder for chaining.

      • addDims

        public TensorNamespace.TensorProto.Builder addDims​(long value)
         The shape of the tensor.
        repeated int64 dims = 1;
        Parameters:
        value - The dims to add.
        Returns:
        This builder for chaining.

      • getDataType

        public int getDataType()
         The data type of the tensor.
 This field MUST have a valid TensorProto.DataType value
        int32 data_type = 2;
        Specified by:
        getDataType in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The dataType.

      • setDataType

        public TensorNamespace.TensorProto.Builder setDataType​(int value)
         The data type of the tensor.
 This field MUST have a valid TensorProto.DataType value
        int32 data_type = 2;
        Parameters:
        value - The dataType to set.
        Returns:
        This builder for chaining.

      • clearDataType

        public TensorNamespace.TensorProto.Builder clearDataType()
         The data type of the tensor.
 This field MUST have a valid TensorProto.DataType value
        int32 data_type = 2;
        Returns:
        This builder for chaining.

      • getFloatDataList

        public List<Float> getFloatDataList()
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Specified by:
        getFloatDataList in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        A list containing the floatData.

      • getFloatDataCount

        public int getFloatDataCount()
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Specified by:
        getFloatDataCount in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The count of floatData.

      • getFloatData

        public float getFloatData​(int index)
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Specified by:
        getFloatData in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The floatData at the given index.

      • setFloatData

        public TensorNamespace.TensorProto.Builder setFloatData​(int index,
                                                        float value)
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The floatData to set.
        Returns:
        This builder for chaining.

      • addFloatData

        public TensorNamespace.TensorProto.Builder addFloatData​(float value)
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Parameters:
        value - The floatData to add.
        Returns:
        This builder for chaining.

      • addAllFloatData

        public TensorNamespace.TensorProto.Builder addAllFloatData​(Iterable<? extends Float> values)
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Parameters:
        values - The floatData to add.
        Returns:
        This builder for chaining.

      • clearFloatData

        public TensorNamespace.TensorProto.Builder clearFloatData()
         For float and complex64 values
 Complex64 tensors are encoded as a single array of floats,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
        repeated float float_data = 4 [packed = true];
        Returns:
        This builder for chaining.

      • getInt32DataList

        public List<Integer> getInt32DataList()
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Specified by:
        getInt32DataList in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        A list containing the int32Data.

      • getInt32DataCount

        public int getInt32DataCount()
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Specified by:
        getInt32DataCount in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The count of int32Data.

      • getInt32Data

        public int getInt32Data​(int index)
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Specified by:
        getInt32Data in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The int32Data at the given index.

      • setInt32Data

        public TensorNamespace.TensorProto.Builder setInt32Data​(int index,
                                                        int value)
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The int32Data to set.
        Returns:
        This builder for chaining.

      • addInt32Data

        public TensorNamespace.TensorProto.Builder addInt32Data​(int value)
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Parameters:
        value - The int32Data to add.
        Returns:
        This builder for chaining.

      • addAllInt32Data

        public TensorNamespace.TensorProto.Builder addAllInt32Data​(Iterable<? extends Integer> values)
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Parameters:
        values - The int32Data to add.
        Returns:
        This builder for chaining.

      • clearInt32Data

        public TensorNamespace.TensorProto.Builder clearInt32Data()
         For int32, uint8, int8, uint16, int16, bool, and float16 values
 float16 values must be bit-wise converted to an uint16_t prior
 to writing to the buffer.
 When this field is present, the data_type field MUST be
 INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
        repeated int32 int32_data = 5 [packed = true];
        Returns:
        This builder for chaining.

      • getStringDataList

        public List<org.nd4j.shade.protobuf.ByteString> getStringDataList()
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Specified by:
        getStringDataList in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        A list containing the stringData.

      • getStringDataCount

        public int getStringDataCount()
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Specified by:
        getStringDataCount in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The count of stringData.

      • getStringData

        public org.nd4j.shade.protobuf.ByteString getStringData​(int index)
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Specified by:
        getStringData in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The stringData at the given index.

      • setStringData

        public TensorNamespace.TensorProto.Builder setStringData​(int index,
                                                         org.nd4j.shade.protobuf.ByteString value)
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Parameters:
        index - The index to set the value at.
        value - The stringData to set.
        Returns:
        This builder for chaining.

      • addStringData

        public TensorNamespace.TensorProto.Builder addStringData​(org.nd4j.shade.protobuf.ByteString value)
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Parameters:
        value - The stringData to add.
        Returns:
        This builder for chaining.

      • addAllStringData

        public TensorNamespace.TensorProto.Builder addAllStringData​(Iterable<? extends org.nd4j.shade.protobuf.ByteString> values)
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Parameters:
        values - The stringData to add.
        Returns:
        This builder for chaining.

      • clearStringData

        public TensorNamespace.TensorProto.Builder clearStringData()
         For strings.
 Each element of string_data is a UTF-8 encoded Unicode
 string. No trailing null, no leading BOM. The protobuf "string"
 scalar type is not used to match ML community conventions.
 When this field is present, the data_type field MUST be STRING
        repeated bytes string_data = 6;
        Returns:
        This builder for chaining.

      • getInt64DataList

        public List<Long> getInt64DataList()
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Specified by:
        getInt64DataList in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        A list containing the int64Data.

      • getInt64DataCount

        public int getInt64DataCount()
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Specified by:
        getInt64DataCount in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The count of int64Data.

      • getInt64Data

        public long getInt64Data​(int index)
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Specified by:
        getInt64Data in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The int64Data at the given index.

      • setInt64Data

        public TensorNamespace.TensorProto.Builder setInt64Data​(int index,
                                                        long value)
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The int64Data to set.
        Returns:
        This builder for chaining.

      • addInt64Data

        public TensorNamespace.TensorProto.Builder addInt64Data​(long value)
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Parameters:
        value - The int64Data to add.
        Returns:
        This builder for chaining.

      • addAllInt64Data

        public TensorNamespace.TensorProto.Builder addAllInt64Data​(Iterable<? extends Long> values)
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Parameters:
        values - The int64Data to add.
        Returns:
        This builder for chaining.

      • clearInt64Data

        public TensorNamespace.TensorProto.Builder clearInt64Data()
         For int64.
 When this field is present, the data_type field MUST be INT64
        repeated int64 int64_data = 7 [packed = true];
        Returns:
        This builder for chaining.

      • setName

        public TensorNamespace.TensorProto.Builder setName​(String value)
         Optionally, a name for the tensor.
        string name = 8;
        Parameters:
        value - The name to set.
        Returns:
        This builder for chaining.

      • setNameBytes

        public TensorNamespace.TensorProto.Builder setNameBytes​(org.nd4j.shade.protobuf.ByteString value)
         Optionally, a name for the tensor.
        string name = 8;
        Parameters:
        value - The bytes for name to set.
        Returns:
        This builder for chaining.

      • getDocStringBytes

        public org.nd4j.shade.protobuf.ByteString getDocStringBytes()
         A human-readable documentation for this tensor. Markdown is allowed.
        string doc_string = 12;
        Specified by:
        getDocStringBytes in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The bytes for docString.

      • setDocString

        public TensorNamespace.TensorProto.Builder setDocString​(String value)
         A human-readable documentation for this tensor. Markdown is allowed.
        string doc_string = 12;
        Parameters:
        value - The docString to set.
        Returns:
        This builder for chaining.

      • clearDocString

        public TensorNamespace.TensorProto.Builder clearDocString()
         A human-readable documentation for this tensor. Markdown is allowed.
        string doc_string = 12;
        Returns:
        This builder for chaining.

      • setDocStringBytes

        public TensorNamespace.TensorProto.Builder setDocStringBytes​(org.nd4j.shade.protobuf.ByteString value)
         A human-readable documentation for this tensor. Markdown is allowed.
        string doc_string = 12;
        Parameters:
        value - The bytes for docString to set.
        Returns:
        This builder for chaining.

      • getRawData

        public org.nd4j.shade.protobuf.ByteString getRawData()
         Serializations can either use one of the fields above, or use this
 raw bytes field. The only exception is the string case, where one is
 required to store the content in the repeated bytes string_data field.
 When this raw_data field is used to store tensor value, elements MUST
 be stored in as fixed-width, little-endian order.
 Floating-point data types MUST be stored in IEEE 754 format.
 Complex64 elements must be written as two consecutive FLOAT values, real component first.
 Complex128 elements must be written as two consecutive DOUBLE values, real component first.
 Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
 Note: the advantage of specific field rather than the raw_data field is
 that in some cases (e.g. int data), protobuf does a better packing via
 variable length storage, and may lead to smaller binary footprint.
 When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
        bytes raw_data = 9;
        Specified by:
        getRawData in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The rawData.

      • setRawData

        public TensorNamespace.TensorProto.Builder setRawData​(org.nd4j.shade.protobuf.ByteString value)
         Serializations can either use one of the fields above, or use this
 raw bytes field. The only exception is the string case, where one is
 required to store the content in the repeated bytes string_data field.
 When this raw_data field is used to store tensor value, elements MUST
 be stored in as fixed-width, little-endian order.
 Floating-point data types MUST be stored in IEEE 754 format.
 Complex64 elements must be written as two consecutive FLOAT values, real component first.
 Complex128 elements must be written as two consecutive DOUBLE values, real component first.
 Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
 Note: the advantage of specific field rather than the raw_data field is
 that in some cases (e.g. int data), protobuf does a better packing via
 variable length storage, and may lead to smaller binary footprint.
 When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
        bytes raw_data = 9;
        Parameters:
        value - The rawData to set.
        Returns:
        This builder for chaining.

      • clearRawData

        public TensorNamespace.TensorProto.Builder clearRawData()
         Serializations can either use one of the fields above, or use this
 raw bytes field. The only exception is the string case, where one is
 required to store the content in the repeated bytes string_data field.
 When this raw_data field is used to store tensor value, elements MUST
 be stored in as fixed-width, little-endian order.
 Floating-point data types MUST be stored in IEEE 754 format.
 Complex64 elements must be written as two consecutive FLOAT values, real component first.
 Complex128 elements must be written as two consecutive DOUBLE values, real component first.
 Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
 Note: the advantage of specific field rather than the raw_data field is
 that in some cases (e.g. int data), protobuf does a better packing via
 variable length storage, and may lead to smaller binary footprint.
 When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
        bytes raw_data = 9;
        Returns:
        This builder for chaining.

      • getExternalDataList

        public List<TensorNamespace.StringStringEntryProto> getExternalDataList()
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;
        Specified by:
        getExternalDataList in interface TensorNamespace.TensorProtoOrBuilder

      • getExternalDataCount

        public int getExternalDataCount()
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;
        Specified by:
        getExternalDataCount in interface TensorNamespace.TensorProtoOrBuilder

      • getExternalData

        public TensorNamespace.StringStringEntryProto getExternalData​(int index)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;
        Specified by:
        getExternalData in interface TensorNamespace.TensorProtoOrBuilder

      • setExternalData

        public TensorNamespace.TensorProto.Builder setExternalData​(int index,
                                                           TensorNamespace.StringStringEntryProto value)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • setExternalData

        public TensorNamespace.TensorProto.Builder setExternalData​(int index,
                                                           TensorNamespace.StringStringEntryProto.Builder builderForValue)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • addExternalData

        public TensorNamespace.TensorProto.Builder addExternalData​(TensorNamespace.StringStringEntryProto value)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • addExternalData

        public TensorNamespace.TensorProto.Builder addExternalData​(int index,
                                                           TensorNamespace.StringStringEntryProto value)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • addExternalData

        public TensorNamespace.TensorProto.Builder addExternalData​(TensorNamespace.StringStringEntryProto.Builder builderForValue)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • addExternalData

        public TensorNamespace.TensorProto.Builder addExternalData​(int index,
                                                           TensorNamespace.StringStringEntryProto.Builder builderForValue)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • addAllExternalData

        public TensorNamespace.TensorProto.Builder addAllExternalData​(Iterable<? extends TensorNamespace.StringStringEntryProto> values)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • clearExternalData

        public TensorNamespace.TensorProto.Builder clearExternalData()
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • removeExternalData

        public TensorNamespace.TensorProto.Builder removeExternalData​(int index)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • getExternalDataBuilder

        public TensorNamespace.StringStringEntryProto.Builder getExternalDataBuilder​(int index)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • getExternalDataOrBuilder

        public TensorNamespace.StringStringEntryProtoOrBuilder getExternalDataOrBuilder​(int index)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;
        Specified by:
        getExternalDataOrBuilder in interface TensorNamespace.TensorProtoOrBuilder

      • getExternalDataOrBuilderList

        public List<? extends TensorNamespace.StringStringEntryProtoOrBuilder> getExternalDataOrBuilderList()
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;
        Specified by:
        getExternalDataOrBuilderList in interface TensorNamespace.TensorProtoOrBuilder

      • addExternalDataBuilder

        public TensorNamespace.StringStringEntryProto.Builder addExternalDataBuilder()
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • addExternalDataBuilder

        public TensorNamespace.StringStringEntryProto.Builder addExternalDataBuilder​(int index)
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • getExternalDataBuilderList

        public List<TensorNamespace.StringStringEntryProto.Builder> getExternalDataBuilderList()
         Data can be stored inside the protobuf file using type-specific fields or raw_data.
 Alternatively, raw bytes data can be stored in an external file, using the external_data field.
 external_data stores key-value pairs describing data location. Recognized keys are:
 - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
                           protobuf model was stored
 - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
 - "length" (optional) - number of bytes containing data. Integer stored as string.
 - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
        repeated .org.nd4j.ir.StringStringEntryProto external_data = 13;

      • getDataLocationValue

        public int getDataLocationValue()
         If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
        .org.nd4j.ir.TensorProto.DataLocation data_location = 14;
        Specified by:
        getDataLocationValue in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The enum numeric value on the wire for dataLocation.

      • setDataLocationValue

        public TensorNamespace.TensorProto.Builder setDataLocationValue​(int value)
         If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
        .org.nd4j.ir.TensorProto.DataLocation data_location = 14;
        Parameters:
        value - The enum numeric value on the wire for dataLocation to set.
        Returns:
        This builder for chaining.

      • clearDataLocation

        public TensorNamespace.TensorProto.Builder clearDataLocation()
         If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
        .org.nd4j.ir.TensorProto.DataLocation data_location = 14;
        Returns:
        This builder for chaining.

      • getDoubleDataList

        public List<Double> getDoubleDataList()
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Specified by:
        getDoubleDataList in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        A list containing the doubleData.

      • getDoubleDataCount

        public int getDoubleDataCount()
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Specified by:
        getDoubleDataCount in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The count of doubleData.

      • getDoubleData

        public double getDoubleData​(int index)
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Specified by:
        getDoubleData in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The doubleData at the given index.

      • setDoubleData

        public TensorNamespace.TensorProto.Builder setDoubleData​(int index,
                                                         double value)
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The doubleData to set.
        Returns:
        This builder for chaining.

      • addDoubleData

        public TensorNamespace.TensorProto.Builder addDoubleData​(double value)
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Parameters:
        value - The doubleData to add.
        Returns:
        This builder for chaining.

      • addAllDoubleData

        public TensorNamespace.TensorProto.Builder addAllDoubleData​(Iterable<? extends Double> values)
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Parameters:
        values - The doubleData to add.
        Returns:
        This builder for chaining.

      • clearDoubleData

        public TensorNamespace.TensorProto.Builder clearDoubleData()
         For double
 Complex128 tensors are encoded as a single array of doubles,
 with the real components appearing in odd numbered positions,
 and the corresponding imaginary component appearing in the
 subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
 is encoded as [1.0, 2.0 ,3.0 ,4.0]
 When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
        repeated double double_data = 10 [packed = true];
        Returns:
        This builder for chaining.

      • getUint64DataList

        public List<Long> getUint64DataList()
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Specified by:
        getUint64DataList in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        A list containing the uint64Data.

      • getUint64DataCount

        public int getUint64DataCount()
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Specified by:
        getUint64DataCount in interface TensorNamespace.TensorProtoOrBuilder
        Returns:
        The count of uint64Data.

      • getUint64Data

        public long getUint64Data​(int index)
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Specified by:
        getUint64Data in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The uint64Data at the given index.

      • setUint64Data

        public TensorNamespace.TensorProto.Builder setUint64Data​(int index,
                                                         long value)
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The uint64Data to set.
        Returns:
        This builder for chaining.

      • addUint64Data

        public TensorNamespace.TensorProto.Builder addUint64Data​(long value)
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Parameters:
        value - The uint64Data to add.
        Returns:
        This builder for chaining.

      • addAllUint64Data

        public TensorNamespace.TensorProto.Builder addAllUint64Data​(Iterable<? extends Long> values)
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Parameters:
        values - The uint64Data to add.
        Returns:
        This builder for chaining.

      • clearUint64Data

        public TensorNamespace.TensorProto.Builder clearUint64Data()
         For uint64 and uint32 values
 When this field is present, the data_type field MUST be
 UINT32 or UINT64
        repeated uint64 uint64_data = 11 [packed = true];
        Returns:
        This builder for chaining.

      • getHalfVal

        public int getHalfVal​(int index)
         For half values (tensorflow compatibility)
        repeated int32 half_val = 15 [packed = true];
        Specified by:
        getHalfVal in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The halfVal at the given index.

      • setHalfVal

        public TensorNamespace.TensorProto.Builder setHalfVal​(int index,
                                                      int value)
         For half values (tensorflow compatibility)
        repeated int32 half_val = 15 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The halfVal to set.
        Returns:
        This builder for chaining.

      • addHalfVal

        public TensorNamespace.TensorProto.Builder addHalfVal​(int value)
         For half values (tensorflow compatibility)
        repeated int32 half_val = 15 [packed = true];
        Parameters:
        value - The halfVal to add.
        Returns:
        This builder for chaining.

      • addAllHalfVal

        public TensorNamespace.TensorProto.Builder addAllHalfVal​(Iterable<? extends Integer> values)
         For half values (tensorflow compatibility)
        repeated int32 half_val = 15 [packed = true];
        Parameters:
        values - The halfVal to add.
        Returns:
        This builder for chaining.

      • clearHalfVal

        public TensorNamespace.TensorProto.Builder clearHalfVal()
         For half values (tensorflow compatibility)
        repeated int32 half_val = 15 [packed = true];
        Returns:
        This builder for chaining.

      • getBoolVal

        public boolean getBoolVal​(int index)
        boolean values
        repeated bool bool_val = 16 [packed = true];
        Specified by:
        getBoolVal in interface TensorNamespace.TensorProtoOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The boolVal at the given index.

      • setBoolVal

        public TensorNamespace.TensorProto.Builder setBoolVal​(int index,
                                                      boolean value)
        boolean values
        repeated bool bool_val = 16 [packed = true];
        Parameters:
        index - The index to set the value at.
        value - The boolVal to set.
        Returns:
        This builder for chaining.

      • addBoolVal

        public TensorNamespace.TensorProto.Builder addBoolVal​(boolean value)
        boolean values
        repeated bool bool_val = 16 [packed = true];
        Parameters:
        value - The boolVal to add.
        Returns:
        This builder for chaining.

      • addAllBoolVal

        public TensorNamespace.TensorProto.Builder addAllBoolVal​(Iterable<? extends Boolean> values)
        boolean values
        repeated bool bool_val = 16 [packed = true];
        Parameters:
        values - The boolVal to add.
        Returns:
        This builder for chaining.

      • setUnknownFields

        public final TensorNamespace.TensorProto.Builder setUnknownFields​(org.nd4j.shade.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        setUnknownFields in interface org.nd4j.shade.protobuf.Message.Builder
        Overrides:
        setUnknownFields in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<TensorNamespace.TensorProto.Builder>

      • mergeUnknownFields

        public final TensorNamespace.TensorProto.Builder mergeUnknownFields​(org.nd4j.shade.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        mergeUnknownFields in interface org.nd4j.shade.protobuf.Message.Builder
        Overrides:
        mergeUnknownFields in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<TensorNamespace.TensorProto.Builder>