Python* API Reference for Intel® Data Analytics Acceleration Library 2019
Specifies methods to access data. More...
Classes | |
| class | CategoricalFeatureDictionary |
| class | DataSourceIface |
| Abstract interface class that defines the interface for a data management component responsible for representation of data in the raw format. More... | |
| class | CsvDataSourceOptions |
| Options of CSV data source. More... | |
| class | StringRowFeatureManagerIface |
| Abstract interface class that defines the interface to parse and convert the raw data represented as a string into a numeric format. More... | |
| class | NumericTableDictionary |
| Class that represents a dictionary of a data set and provides methods to work with the data dictionary. More... | |
| class | DataSourceDictionary |
| Class that represents a dictionary of a data set and provides methods to work with the data dictionary. More... | |
| class | BlockDescriptor |
| Base class that manages buffer memory for read/write operations required by numeric tables. More... | |
| class | CSRBlockDescriptor |
| Base class that manages buffer memory for read/write operations required by CSR numeric tables. More... | |
| class | Compressor |
| Implementation of the Compressor class for the bzip2 compression method. More... | |
| class | Decompressor |
| Specialization of Decompressor class for Bzip2 compression method. More... | |
| class | HomogenNumericTable |
| Class that provides methods to access data stored as a contiguous array of homogeneous feature vectors. More... | |
| class | HomogenTensor |
| Class that provides methods to access data stored as a contiguous array of homogeneous data in rows-major format. More... | |
| class | KeyValueCollection |
| Class that provides functionality of a key-value container for objects derived from the T with a key of the size_t type. More... | |
| class | Matrix |
| Represents a two-dimensional table of numbers of the same type. More... | |
| class | SerializableKeyValueCollection |
| Class that provides functionality of a key-value container for objects derived from the SerializationIface interface with a key of the size_t type. More... | |
| class | SubtensorDescriptor |
| Class with descriptor of the subtensor retrieved from Tensor getSubTensor function. More... | |
| class | DataSourceTemplate |
| Implements the abstract DataSourceIface interface. More... | |
| class | CsvDataSource |
| Specifies methods to access data stored in files. More... | |
| class | FileDataSource |
| Specifies methods to access data stored in files. More... | |
| class | PackedSymmetricMatrix |
| Class that provides methods to access symmetric matrices stored as a one-dimensional array. More... | |
| class | PackedTriangularMatrix |
| Class that provides methods to access a packed triangular matrix stored as a one-dimensional array. More... | |
| class | StringDataSource |
| Specifies methods to access data stored in byte arrays in the C-string format. More... | |
| class | KeyValueDataCollection |
| Class that provides functionality of a key-value container for objects derived from the SerializationIface interface with a key of the size_t type. More... | |
| class | SQLFeatureManager |
| Interprets the response of SQL data base and fill provided numeric table and dictionary. More... | |
| class | ODBCDataSourceOptions |
| Options of ODBC data source. More... | |
Methods of the class to preprocess data represented in the CSV format.
| def __getitem__ | ( | self, | |
| i | |||
| ) |
read operator []
| def __getitem__ | ( | self, | |
| i | |||
| ) |
read operator []
| def __getitem__ | ( | self, | |
| i | |||
| ) |
read operator []
| def __getitem__ | ( | self, | |
| i | |||
| ) |
read operator []
| def __getitem__ | ( | self, | |
| i | |||
| ) |
read operator []
| def __init__ | ( | self, | |
| args | |||
| ) |
__init__(daal.data_management.DataBlock self) -> DataBlock
| def __init__ | ( | self, | |
| args | |||
| ) |
Default constructor
| clevel | Compression level, CompressionLevel |
| def __init__ | ( | self, | |
| args | |||
| ) |
CompressionStream constructor
| compr | Pointer to a specific Compressor used for compression |
| minSize | Optional parameter, minimal size of internal data blocks |
| def __init__ | ( | self, | |
| args | |||
| ) |
| decompr | Pointer to a specific Decompressor used for decompression |
| minSize | Optional parameter, minimal size of internal data blocks |
| def __init__ | ( | self, | |
_preHeadBytes = 0, |
|||
_postHeadBytes = 0 |
|||
| ) |
LzoCompressionParameter constructor
| _preHeadBytes | Size in bytes of section 1 of the LZO compressed block header |
| _postHeadBytes | Size in bytes of section 4 of the LZO compressed block header |
| def __init__ | ( | self, | |
_isBlockHeader = 1 |
|||
| ) |
RleCompressionParameter constructor
| _isBlockHeader | RLE block header presence flag. True if a RLE block header is present, false otherwise |
| def __init__ | ( | self, | |
| args | |||
| ) |
ZlibCompressionParameter constructor
| clevel | Optional parameter, CompressionLevel. defaultLevel is equal to zlib compression level 6 |
| bgzHeader | Optional flag. True if a simple GZIP header is included, false otherwise |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor of an empty data archive
Copy constructor of a data archive
Constructor of a data archive from data in a byte array
| ptr | Pointer to the array that represents the data |
| size | Size of the data array |
| def __init__ | ( | self, | |
| compressor | |||
| ) |
Constructor of a compressed data archive from compressor
| compressor | Pointer to the compressor |
| def __init__ | ( | self, | |
| decompressor | |||
| ) |
Constructor of a decompressed data archive from decompressor
| decompressor | Pointer to the decompressor |
| def __init__ | ( | self, | |
| args | |||
| ) |
Default constructor
Constructor of an input data archive from a DataArchiveIface The new InputDataArchive object will own the provided pointer and free it when it gets deleted.
Constructor of an input data archive to a byte array of compressed data
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor of an output data archive from an input data archive
Constructor of an output data archive from a DataArchiveIface The new OutputDataArchive object will own the provided pointer and free it when it gets deleted.
Constructor of an output data archive from a byte array
Constructor of an output data archive from a byte array of compressed data
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor with a defined number of elements
| n | Number of elements |
| def __init__ | ( | self | ) |
__init__(daal.data_management.DictionaryIface self) -> DictionaryIface
| def __init__ | ( | self | ) |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor of a data feature
Copy constructor for a data feature
| def __init__ | ( | self | ) |
__init__(daal.data_management.NumericTable.BasicStatisticsDataCollection self) -> BasicStatisticsDataCollection
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for TensorOffsetLayout with default layout
| dims | The size of dimensions in the Tensor layout |
Constructor for TensorOffsetLayout with layout defined with offsets between adjacent elements in each dimension
| dims | The size of dimensions in the Tensor layout |
| offsets | The offsets between adjacent elements in each dimension |
| indices | Collection with dimensions order |
| def __init__ | ( | self, | |
| ary | |||
| ) |
Constructor for a Numeric Table with user-allocated memory
| ary | The structured array |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for an empty Numeric Table
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| featuresEqual | Flag that makes all features in the NumericTableDictionary equal |
Constructor for an empty Numeric Table with a predefined NumericTableDictionary
| ddict | Pointer to the predefined NumericTableDictionary |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for an empty Numeric Table with a predefined NumericTableDictionary
| ddict | Pointer to the predefined NumericTableDictionary |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for an empty Numeric Table with a predefined NumericTableDictionary
| ddict | Shared pointer to the predefined NumericTableDictionary |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for an empty Numeric Table with a predefined NumericTableDictionary
| ddict | Shared pointer to the predefined NumericTableDictionary |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for an empty CSR Numeric Table
| values | numpy array with double values |
| colIndices | numpy array with column indices (long ints) |
| rowOffsets | numpy array with row offsets (long ints) |
| values | numpy array with float values |
| colIndices | numpy array with column indices (long ints) |
| rowOffsets | numpy array with row offsets (long ints) |
| values | numpy array with int values |
| colIndices | numpy array with column indices (long ints) |
| rowOffsets | numpy array with row offsets (long ints) |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for an empty merge Numeric Table
Constructor for a merge Numeric Table consisting of one table
| table | Pointer to the table |
Constructor for a merge Numeric Table consisting of two tables
| first | Pointer to the first table |
| second | Pointer to the second table |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for an empty merge Numeric Table
Constructor for a Row Merged Numeric Table consisting of one table
| table | Pointer to the table |
| def __init__ | ( | self, | |
| args | |||
| ) |
__init__(daal.data_management.CsvDataSourceOptions self, daal.data_management.CsvDataSourceOptions.Value flags) -> CsvDataSourceOptions
| def __init__ | ( | self, | |
| args | |||
| ) |
__init__(daal.data_management.FeatureAuxData self) -> FeatureAuxData
| def __init__ | ( | self, | |
| idx | |||
| ) |
__init__(daal.data_management.MakeCategorical self, size_t idx) -> MakeCategorical
| def __init__ | ( | self, | |
| idx, | |||
| nCats | |||
| ) |
__init__(daal.data_management.OneHotEncoder self, size_t idx, size_t nCats) -> OneHotEncoder
| def __init__ | ( | self | ) |
__init__(daal.data_management.ColumnFilter self) -> ColumnFilter
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor of a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
Constructor of a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
Default constructor of a data dictionary
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor of a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
Constructor of a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
Default constructor of a data dictionary
| def __init__ | ( | self | ) |
| def __init__ | ( | self | ) |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for an empty Numeric Table with a predefined NumericTableDictionary
| ddict | Pointer to the predefined NumericTableDictionary |
Constructor for an empty Numeric Table with a predefined NumericTableDictionary
| ddictForHomogenNumericTable | Pointer to the predefined NumericTableDictionary |
Constructor for an empty Numeric Table
Constructor for a Numeric Table with user-allocated memory
| ptr | Pointer to and an array with a homogeneous data set |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
Constructor for a Numeric Table with user-allocated memory
| featuresEqual | Flag that makes all features in the Numeric Table Data Dictionary equal |
| ptr | Pointer to and an array with a homogeneous data set |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
Constructor for a Numeric Table with user-allocated memory and filling the table with a constant
| ptr | Pointer to and an array with a homogeneous data set |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| constValue | Constant to initialize entries of the homogeneous numeric table |
Constructor for a Numeric Table with user-allocated memory and filling the table with a constant
| featuresEqual | Flag that makes all features in the Numeric Table Data Dictionary equal |
| ptr | Pointer to and an array with a homogeneous data set |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| constValue | Constant to initialize entries of the homogeneous numeric table |
Constructor for a Numeric Table with memory allocation controlled via a flag
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for a Numeric Table with memory allocation controlled via a flag
| featuresEqual | Flag that makes all features in the Numeric Table Data Dictionary equal |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Overload 10:*
Constructor for a Numeric Table with memory allocation controlled via a flag and filling the table with a constant
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| constValue | Constant to initialize entries of the homogeneous numeric table |
Overload 11:*
Constructor for a numeric table with memory allocation controlled via a flag and filling the table with a constant
| featuresEqual | Flag that makes all features in the numeric table data dictionary equal |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| constValue | Constant to initialize entries of the homogeneous numeric table |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructs an empty homogeneous tensor
Constructs homogeneous tensor with a user-defined data, number and sizes of dimensions
| nDim | Number of dimensions |
| dimSizes | Array with sizes for each dimension |
| data | Array with a homogeneous data set |
Constructs homogeneous tensor with a user-defined dimensions and memory allocation flag
| dims | Collection of tensor dimensions |
| memoryAllocationFlag | Flag specifying memory allocation |
Constructs homogeneous tensor with a user-defined dimensions, memory allocation flag and fills it with the constant values
| dims | Collection of tensor dimensions |
| memoryAllocationFlag | Flag specifying memory allocation |
| initValue | Constant value |
| def __init__ | ( | self, | |
| args | |||
| ) |
__init__(daal.data_management.KeyValueCollection<(daal.data_management.SerializationIface)> self) -> KeyValueCollection
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for a Numeric Table with memory allocation controlled via a flag
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for a Numeric Table with memory allocation controlled via a flag
| featuresEqual | Flag that makes all features in the Numeric Table Data Dictionary equal |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for a Numeric Table with memory allocation controlled via a flag and filling the table with a constant
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| constValue | Constant to initialize entries of the homogeneous numeric table |
Constructor for a Numeric Table with memory allocation controlled via a flag and filling the table with a constant
| featuresEqual | Flag that makes all features in the Numeric Table Data Dictionary equal |
| nColumns | Number of columns in the table |
| nRows | Number of rows in the table |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| constValue | Constant to initialize entries of the homogeneous numeric table |
| narray | numpy array |
| narray | numpy array |
| value | value to fill matrix with |
| def __init__ | ( | self, | |
| args | |||
| ) |
__init__(daal.data_management.SerializableKeyValueCollection<(daal.data_management.SerializationIface)> self) -> SerializableKeyValueCollection
| def __init__ | ( | self | ) |
Constructor for an empty subtensor descriptor
| def __init__ | ( | self, | |
| args | |||
| ) |
Main constructor for a Data Source
| fileName | Name of the file that stores data |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| fileName | Name of the file that stores data |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| fileName | Name of the file that stores data |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| fileName | Name of the file that stores data |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| fileName | Name of the file that stores data |
| options | Options of data source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| fileName | Name of the file that stores data |
| options | Options of data source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for a Numeric Table with user-allocated memory
| ptr | Pointer to and an array with a homogeneous data set |
| nDim | Matrix dimension |
Constructor for a Numeric Table with user-allocated memory and filling the table with a constant
| ptr | Pointer to and an array with a homogeneous data set |
| nDim | Matrix dimension |
| constValue | Constant to initialize entries of the packed symmetric matrix |
Constructor for a Numeric Table with memory allocation controlled via a flag and filling the table with a constant
| nDim | Matrix dimension |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| constValue | Constant to initialize entries of the packed symmetric matrix |
| def __init__ | ( | self, | |
| args | |||
| ) |
Constructor for a Numeric Table with user-allocated memory
| ptr | Pointer to and an array with a homogeneous data set |
| nDim | Matrix dimension |
Constructor for a Numeric Table with user-allocated memory and filling the table with a constant
| ptr | Pointer to and an array with a homogeneous data set |
| nDim | Matrix dimension |
| constValue | Constant to initialize entries of the packed symmetric matrix |
Constructor for a Numeric Table with memory allocation controlled via a flag
| nDim | Matrix dimension |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
Constructor for a Numeric Table with memory allocation controlled via a flag and filling the table with a constant
| nDim | Matrix dimension |
| memoryAllocationFlag | Flag that controls internal memory allocation for data in the numeric table |
| constValue | Constant to initialize entries of the packed symmetric matrix |
| def __init__ | ( | self, | |
| args | |||
| ) |
Main constructor for a Data Source
| data | Byte array in the C-string format |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| data | Byte array in the C-string format |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| data | Byte array in the C-string format |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
Main constructor for a Data Source
| data | Byte array in the C-string format |
| doAllocateNumericTable | Flag that specifies whether a Numeric Table associated with a File Data Source is allocated inside the Data Source |
| doCreateDictionaryFromContext | Flag that specifies whether a Data Dictionary is created from the context of the File Data Source |
| initialMaxRows | Initial value of maximum number of rows in Numeric Table allocated in loadDataBlock() method |
| def __init__ | ( | self, | |
| args | |||
| ) |
__init__(daal.data_management.SerializableKeyValueCollection<(daal.data_management.SerializationIface)> self) -> KeyValueDataCollection
| def __lshift__ | ( | self, | |
| inBlock | |||
| ) |
| def __lshift__ | ( | self, | |
| inBlock | |||
| ) |
| def __lshift__ | ( | self, | |
| x | |||
| ) |
Adds an element to the end of a collection
| x | Element to add |
| def __setitem__ | ( | self, | |
| i, | |||
| v | |||
| ) |
write operator []
| def __setitem__ | ( | self, | |
| i, | |||
| v | |||
| ) |
write operator []
| def __setitem__ | ( | self, | |
| i, | |||
| v | |||
| ) |
write operator []
| def __setitem__ | ( | self, | |
| i, | |||
| v | |||
| ) |
write operator []
| def addNumericTable | ( | self, | |
| table | |||
| ) |
Adds the table to the right of the merge Numeric Table
| table | Pointer to the table |
| def addNumericTable | ( | self, | |
| table | |||
| ) |
Adds the table to the bottom of the Row Merged Numeric Table
| table | Pointer to the table |
| def allocateBasicStatistics | ( | self | ) |
Allocates Numeric Tables for basic statistics
| def allocateBasicStatistics | ( | self | ) |
Allocates Numeric Tables for basic statistics
| def allocateBasicStatistics | ( | self | ) |
allocateBasicStatistics(MergedNumericTable self) -> Status
| def allocateDataMemory | ( | self, | |
| args | |||
| ) |
Allocates memory for a data set
| def allocateDataMemory | ( | self, | |
| args | |||
| ) |
allocateDataMemory(NumericTable self, daal.MemType type) -> Status
| def allocateDataMemory | ( | self, | |
| args | |||
| ) |
Allocates memory for a data set
| def allocateDataMemory | ( | self, | |
| args | |||
| ) |
allocateDataMemory(Tensor self, daal.MemType type) -> Status
| def allocateDataMemory | ( | self, | |
| args | |||
| ) |
allocateDataMemory(AOSNumericTable self, daal.MemType type) -> Status
| def allocateDataMemory | ( | self, | |
| args | |||
| ) |
Allocates memory for a data set
| dataSize | Number of non-zero values |
| type | Memory type |
| def allocateNumericTable | ( | self | ) |
Allocates a Numeric Table associated with a Data Source
| def allocateNumericTable | ( | self | ) |
allocateNumericTable(DataSourceTemplate self) -> Status
| def apply | ( | self, | |
| funcList, | |||
| auxVect | |||
| ) |
apply(ModifierIface self, daal.services.Collection< daal.data_management.functionT > & funcList, daal.services.Collection< daal.data_management.FeatureAuxData > & auxVect)
| def apply | ( | self, | |
| funcList, | |||
| auxVect | |||
| ) |
apply(MakeCategorical self, daal.services.Collection< daal.data_management.functionT > & funcList, daal.services.Collection< daal.data_management.FeatureAuxData > & auxVect)
| def apply | ( | self, | |
| funcList, | |||
| auxVect | |||
| ) |
apply(OneHotEncoder self, daal.services.Collection< daal.data_management.functionT > & funcList, daal.services.Collection< daal.data_management.FeatureAuxData > & auxVect)
| def apply | ( | self, | |
| funcList, | |||
| auxVect | |||
| ) |
apply(ColumnFilter self, daal.services.Collection< daal.data_management.functionT > & funcList, daal.services.Collection< daal.data_management.FeatureAuxData > & auxVect)
| def archiveFooter | ( | self | ) |
Generates a footer for a data archive
| def archiveFooter | ( | self | ) |
Reads the footer from a data archive
| def archiveHeader | ( | self | ) |
Generates a header for a data archive
| def archiveHeader | ( | self | ) |
Reads the header from a data archive
| def assign | ( | self, | |
| args | |||
| ) |
Fills a numeric table with a constant
| value | Constant to initialize entries of the numeric table |
Fills a numeric table with a constant
| value | Constant to initialize entries of the numeric table |
Fills a numeric table with a constant
| value | Constant to initialize entries of the numeric table |
| def assign | ( | self, | |
| args | |||
| ) |
| def assign | ( | self, | |
| initValue | |||
| ) |
Fills a tensor with a constant value
| initValue | Constant value to initialize entries of the homogeneous tensor |
| def assign | ( | self, | |
| args | |||
| ) |
| def assign | ( | self, | |
| args | |||
| ) |
| def catFunc | ( | word, | |
| aux, | |||
| arr | |||
| ) |
catFunc(char const * word, FeatureAuxData aux, double * arr)
| def check | ( | self, | |
| description, | |||
checkDataAllocation = True |
|||
| ) |
Checks the correctness of this numeric table
| description | Additional information about error |
| checkDataAllocation | Flag that specifies whether to check the data allocation status |
| def check | ( | self, | |
| description, | |||
checkDataAllocation = True |
|||
| ) |
| def check | ( | self, | |
| description | |||
| ) |
Checks the correctness of this tensor
| description | Additional information about error |
| def check | ( | self, | |
| description | |||
| ) |
Checks the correctness of this tensor
| description | Additional information about error |
| def check | ( | self, | |
| description, | |||
checkDataAllocation = True |
|||
| ) |
| def checkDictionary | ( | self | ) |
checkDictionary(NumericTableDictionary self) -> Status
| def checkDictionary | ( | self | ) |
checkDictionary(DataSourceDictionary self) -> Status
| def checkInputParams | ( | self, | |
| inBlock | |||
| ) |
Basic checks of input block parameters
| inBlock | Pointer to the input data block |
| size | Size in bytes of the input data block |
| def checkOutputParams | ( | self, | |
| outBlock | |||
| ) |
Basic checks of output block parameters
| outBlock | Pointer to output data block |
| size | Size in bytes of the output data block |
| def clear | ( | self | ) |
Clears a collection: removes an array, sets the size and capacity to 0
| def clear | ( | self | ) |
Removes all elements from a container
| def contFunc | ( | word, | |
| aux, | |||
| arr | |||
| ) |
contFunc(char const * word, FeatureAuxData aux, double * arr)
| def daal.data_management.convertToHomogen_Float32 | ( | args | ) |
Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
| src | Pointer to numeric table |
| type | Type of result numeric table memory |
Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
| src | Pointer to numeric table |
| type | Type of result numeric table memory |
| def daal.data_management.convertToHomogen_Float64 | ( | args | ) |
Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
| src | Pointer to numeric table |
| type | Type of result numeric table memory |
Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
| src | Pointer to numeric table |
| type | Type of result numeric table memory |
| def daal.data_management.convertToHomogen_Intc | ( | args | ) |
Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
| src | Pointer to numeric table |
| type | Type of result numeric table memory |
Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
| src | Pointer to numeric table |
| type | Type of result numeric table memory |
| def copyArchiveToArray | ( | self, | |
| ptr | |||
| ) |
Copies a data archive in the byte format to user-specified memory
| ptr | Pointer to the byte array |
| maxLength | Size of the array |
| def copyArchiveToArray | ( | self, | |
| ptr | |||
| ) |
copyArchiveToArray(DataArchive self, daal.byte * ptr) -> size_t
| def copyArchiveToArray | ( | self, | |
| ptr | |||
| ) |
copyArchiveToArray(CompressedDataArchive self, daal.byte * ptr) -> size_t
| def copyArchiveToArray | ( | self, | |
| ptr | |||
| ) |
copyArchiveToArray(DecompressedDataArchive self, daal.byte * ptr) -> size_t
| def copyArchiveToArray | ( | self, | |
| ptr | |||
| ) |
Copies a data archive in the byte format to user-specified memory
| ptr | Pointer to the byte array |
| maxLength | Size of the array |
| def copyCompressedArray | ( | self, | |
| args | |||
| ) |
Copies compressed data stored in CompressionStream to an external array
| outPtr | Pointer to the array where compressed data is stored |
| outSize | Number of bytes available in external memory |
Copies compressed data stored in CompressionStream to an external DataBlock
| outBlock | Reference to the DataBlock where compressed data is stored |
| def copyDecompressedArray | ( | self, | |
| args | |||
| ) |
Copies decompressed data stored in DecompressionStream to an external array
| outPtr | Pointer to the array where decompressed data is stored |
| outSize | Number of bytes available in external memory |
Copies decompressed data stored in DecompressionStream to an external DataBlock
| def create | ( | args | ) |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
| def create | ( | args | ) |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
| def createDefaultSubtensorLayout | ( | self | ) |
createDefaultSubtensorLayout(DenseTensorIface self) -> TensorOffsetLayout
| def createDefaultSubtensorLayout | ( | self | ) |
Creates default tensor layout
| def createDictionaryFromContext | ( | self | ) |
Creates a Data Dictionary by extracting information from a Data Source
| def createDictionaryFromContext | ( | self | ) |
createDictionaryFromContext(DataSource self) -> Status
| def createDictionaryFromContext | ( | self | ) |
createDictionaryFromContext(CsvDataSource self) -> Status
| def createDictionaryFromContext | ( | self | ) |
createDictionaryFromContext(FileDataSource self) -> Status
| def createDictionaryFromContext | ( | self | ) |
createDictionaryFromContext(StringDataSource self) -> Status
| def createRawSubtensorLayout | ( | self | ) |
createRawSubtensorLayout(DenseTensorIface self) -> TensorOffsetLayout
| def createRawSubtensorLayout | ( | self | ) |
Creates raw tensor layout
| def daal.data_management.DataSourceDictionary_create | ( | args | ) |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
| def daal.data_management.DataSourceDictionary_serializationTag | ( | ) |
| def deserialize | ( | self, | |
| archive | |||
| ) |
Performs deserialization
| archive | Storage for a deserialized object or data structure |
| def erase | ( | self, | |
| pos | |||
| ) |
Erase an element from a position
| pos | Position to erase |
| def even | ( | self | ) |
even(ColumnFilter self) -> ColumnFilter
| def freeDataMemory | ( | self | ) |
Deallocates the memory allocated for a data set
| def freeDataMemory | ( | self | ) |
freeDataMemory(NumericTable self)
| def freeDataMemory | ( | self | ) |
Deallocates the memory allocated for a data set
| def freeDataMemory | ( | self | ) |
freeDataMemory(Tensor self) -> Status
| def freeDataMemory | ( | self | ) |
freeDataMemory(AOSNumericTable self)
| def freeNumericTable | ( | self | ) |
Returns a pointer to a Numeric Table associated with a Data Source
| def freeNumericTable | ( | self | ) |
freeNumericTable(DataSourceTemplate self)
| def get | ( | self | ) |
Performs deserialization of the objects stored in output data archive
| def get | ( | self, | |
| args | |||
| ) |
Element access
| index | Index of an accessed element |
Const element access
| index | Index of an accessed element |
| def get | ( | self, | |
| id | |||
| ) |
get(BasicStatisticsDataCollection self, daal.data_management.NumericTableIface.BasicStatisticsId id) -> daal.services.SharedPtr< daal.data_management.NumericTable >
| def getAdditionalBufferPtr | ( | self | ) |
Gets a pointer o the additional memory buffer
| def getAdditionalBufferSharedPtr | ( | self | ) |
getAdditionalBufferSharedPtr(BlockDescriptor self) -> daal.services.SharedPtr< double >
| def getArchiveAsArray | ( | self | ) |
Returns Archive data as numpy byte array.
| def getArchiveAsArray | ( | self | ) |
Returns Archive data as numpy byte array.
| def getArchiveAsString | ( | self | ) |
Returns a data archive in the STL string format
| def getArchiveAsString | ( | self | ) |
getArchiveAsString(DataArchive self) -> std.string
| def getArchiveAsString | ( | self | ) |
getArchiveAsString(CompressedDataArchive self) -> std.string
| def getArchiveAsString | ( | self | ) |
getArchiveAsString(DecompressedDataArchive self) -> std.string
| def getArchiveAsString | ( | self | ) |
Returns a data archive in the STL string format
| def getArray | ( | self | ) |
Returns block as array.
| def getArray | ( | self, | |
| index | |||
| ) |
Returns a pointer to a numpy array of values for a given feature
| index | Feature index |
| def getArray | ( | self | ) |
Returns data block of this descriptor as double numpy array.
| def getArray | ( | self | ) |
Returns data of entire table as double numpy array.
| def getArray | ( | self | ) |
Returns data of entire tensor as double numpy array.
| def getArray | ( | self | ) |
Returns data block of this descriptor as double numpy array.
| def getArrays | ( | self | ) |
Returns numpy arrays with the data set stored in the CSR layout
| def getBlockColumnIndices | ( | self | ) |
Returns column indices.
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
Gets a block of values for a given feature.
| feature_idx | Feature index. |
| vector_idx | Index of the first feature vector to include into the block. |
| value_num | Number of feature values in the block. |
| rwflag | Flag specifying read/write access to the block of feature values. |
| block | The block of feature values. |
Gets a block of values for a given feature.
| feature_idx | Feature index. |
| vector_idx | Index of the first feature vector to include into the block. |
| value_num | Number of feature values in the block. |
| rwflag | Flag specifying read/write access to the block of feature values. |
| block | The block of feature values. |
Gets a block of values for a given feature.
| feature_idx | Feature index. |
| vector_idx | Index of the first feature vector to include into the block. |
| value_num | Number of feature values in the block. |
| rwflag | Flag specifying read/write access to the block of feature values. |
| block | The block of feature values. |
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(AOSNumericTable self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(SOANumericTable self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(CSRNumericTable self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(MergedNumericTable self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(RowMergedNumericTable self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(HomogenNumericTable self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(PackedSymmetricMatrix self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
getBlockOfColumnValues(PackedTriangularMatrix self, size_t feature_idx, size_t vector_idx, size_t value_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfColumnValuesAsDouble | ( | self, | |
| feature_idx, | |||
| vector_idx, | |||
| value_num | |||
| ) |
Returns and array for the given column-block specification as double
| feature_idx | Feature index. |
| vector_idx | Index of the first feature vector to include into the block. |
| value_num | Number of feature values in the block. |
| def getBlockOfColumnValuesAsFloat | ( | self, | |
| feature_idx, | |||
| vector_idx, | |||
| value_num | |||
| ) |
Returns and array for the given column-block specification as float
| feature_idx | Feature index. |
| vector_idx | Index of the first feature vector to include into the block. |
| value_num | Number of feature values in the block. |
| def getBlockOfColumnValuesAsInt | ( | self, | |
| feature_idx, | |||
| vector_idx, | |||
| value_num | |||
| ) |
Returns and array for the given column-block specification as int
| feature_idx | Feature index. |
| vector_idx | Index of the first feature vector to include into the block. |
| value_num | Number of feature values in the block. |
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
Gets a block of rows from a table.
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| rwflag | Flag specifying read/write access to the block of feature vectors. |
| block | The block of feature vectors. |
Gets a block of rows from a table.
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| rwflag | Flag specifying read/write access to the block of feature vectors. |
| block | The block of feature vectors. |
Gets a block of rows from a table.
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| rwflag | Flag specifying read/write access to the block of feature vectors. |
| block | The block of feature vectors. |
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(AOSNumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(SOANumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(CSRNumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(MergedNumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(RowMergedNumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(HomogenNumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(PackedSymmetricMatrix self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRows | ( | self, | |
| args | |||
| ) |
getBlockOfRows(PackedTriangularMatrix self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getBlockOfRowsAsDouble | ( | self, | |
| vector_idx, | |||
| vector_num | |||
| ) |
Returns and array for the given row-block spcification as double
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| def getBlockOfRowsAsFloat | ( | self, | |
| vector_idx, | |||
| vector_num | |||
| ) |
Returns and array for the given row-block spcification as float
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| def getBlockOfRowsAsInt | ( | self, | |
| vector_idx, | |||
| vector_num | |||
| ) |
Returns and array for the given row-block spcification as int
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| def getBlockRowIndices | ( | self | ) |
Returns row inidces.
| def getBlockSharedPtr | ( | self | ) |
Gets a pointer to the buffer
| def getBlockValues | ( | self | ) |
Returns values as double.
| def getBlockValuesPtr | ( | self | ) |
Gets a pointer to the buffer
| def getBlockValuesSharedPtr | ( | self | ) |
Gets a pointer to the buffer
| def getCategoricalDictionary | ( | self | ) |
Gets a categorical features dictionary
| def getColumnsOffset | ( | self | ) |
Gets the number of columns in the numeric table preceding the first element in the block
| def getCompressedBlocksCollection | ( | self | ) |
Provides access to compressed data blocks stored in CompressionStream
| def getCompressedDataSize | ( | self | ) |
Returns the size of compressed data stored in CompressionStream
| def getCSRIndexing | ( | self | ) |
Returns the indexing scheme for access to data in the CSR layout
| def getData | ( | self | ) |
Gets data source string data
| def getDataArchive | ( | self | ) |
Returns a data archive object of the InputDataArchive type
| def getDataLayout | ( | self | ) |
Returns a data layout used in the Numeric Table
| def getDataLayout | ( | self | ) |
getDataLayout(NumericTable self) -> daal.data_management.NumericTableIface.StorageLayout
| def getDataMemoryStatus | ( | self | ) |
Gets the status of the memory used by a data set connected with a Numeric Table
| def getDataMemoryStatus | ( | self | ) |
Gets the status of the memory used by a data set connected with a Tensor
| def getDataMemoryStatus | ( | self | ) |
getDataMemoryStatus(MergedNumericTable self) -> daal.data_management.NumericTableIface.MemoryStatus
| def getDataMemoryStatus | ( | self | ) |
getDataMemoryStatus(RowMergedNumericTable self) -> daal.data_management.NumericTableIface.MemoryStatus
| def getDataSize | ( | self | ) |
Returns number of elements in values array.
| def getDataSize | ( | self | ) |
getDataSize(CSRNumericTable self) -> size_t
| def getDataSize | ( | self | ) |
Returns number of elements in values array.
| def getDecompressedBlocksCollection | ( | self | ) |
Provides access to decompressed data blocks stored in DecompressionStream
| def getDecompressedDataSize | ( | self | ) |
Returns the size of decompressed data stored in DecompressionStream
| def getDictionary | ( | self | ) |
Returns a pointer to a data dictionary
| def getDictionary | ( | self | ) |
getDictionary(NumericTable self) -> NumericTableDictionary
| def getDictionary | ( | self | ) |
Returns a pointer to a data dictionary
| def getDictionary | ( | self | ) |
getDictionary(DataSource self) -> DataSourceDictionary
| def getDictionaryCreationFlag | ( | self | ) |
getDictionaryCreationFlag(CsvDataSourceOptions self) -> daal.data_management.DataSource.DictionaryCreationFlag
| def getDimensions | ( | self | ) |
Gets the size of dimensions in the Tensor layout
| def getDimensions | ( | self | ) |
Gets the size of dimensions in the Tensor
| def getDimensionSize | ( | self, | |
| dimIdx | |||
| ) |
Gets the size of the dimension in the Tensor
| dimIdx | Index of dimension |
| def getErrors | ( | self | ) |
getErrors(Compression self) -> daal.services.SharedPtr< daal.services.ErrorCollection >
| def getErrors | ( | self | ) |
getErrors(CompressionStream self) -> daal.services.SharedPtr< daal.services.ErrorCollection >
| def getErrors | ( | self | ) |
getErrors(DecompressionStream self) -> daal.services.SharedPtr< daal.services.ErrorCollection >
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
For backward compatibility. Returns errors stored on the object
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getErrors | ( | self | ) |
Returns errors during the computation
| def getFeatureManager | ( | self | ) |
Returns a feature manager associated with a File Data Source
| def getFeatureName | ( | self | ) |
Returns the name of the feature
| def getFeaturesEqual | ( | self | ) |
Returns the value of the featuresEqual flag
| def getFeaturesEqual | ( | self | ) |
Returns the value of the featuresEqual flag
| def getFeatureType | ( | self, | |
| feature_idx | |||
| ) |
Returns the type of a given feature
| feature_idx | Feature index |
| def getFeatureType | ( | self, | |
| feature_idx | |||
| ) |
getFeatureType(NumericTable self, size_t feature_idx) -> daal.data_management.features.FeatureType
| def getFixedDimNums | ( | self | ) |
Gets values at which dimensions are fixed
| def getFixedDims | ( | self | ) |
Gets the number of first dimension with fixed values
| def getIndexType | ( | self | ) |
getIndexType(DataSourceFeature self) -> daal.data_management.features.IndexNumType
| def getIndices | ( | self | ) |
Gets the dimensions order
| def getInplaceFlag | ( | self | ) |
Returns subtensor inplace flag
| def getKeyByIndex | ( | self, | |
| idx | |||
| ) |
Returns a reference to SharedPtr for a stored key with a given index
| idx | Index of the requested key |
| def getLayout | ( | self | ) |
Returns subtensor layout
| def getLayoutPtr | ( | self | ) |
getLayoutPtr(Tensor self) -> TensorLayout
| def getMajorVersion | ( | self | ) |
Returns the major version of the archive
| def getMajorVersion | ( | self | ) |
getMajorVersion(DataArchiveImpl self) -> int
| def getMajorVersion | ( | self | ) |
Returns the major version of the library used for object serialization
| def getMinorVersion | ( | self | ) |
Returns the minor version of the archive
| def getMinorVersion | ( | self | ) |
getMinorVersion(DataArchiveImpl self) -> int
| def getMinorVersion | ( | self | ) |
Returns the minor version of the library used for object serialization
| def getNumberOfAvailableRows | ( | self | ) |
Returns the number of rows available in a Data Source
| def getNumberOfAvailableRows | ( | self | ) |
getNumberOfAvailableRows(CsvDataSource self) -> size_t
| def getNumberOfCategories | ( | self, | |
| feature_idx | |||
| ) |
Returns the number of categories for a given feature
| feature_idx | Feature index |
| def getNumberOfCategories | ( | self, | |
| feature_idx | |||
| ) |
getNumberOfCategories(NumericTable self, size_t feature_idx) -> size_t
| def getNumberOfColumns | ( | self | ) |
Returns the number of columns in the Numeric Table
| def getNumberOfColumns | ( | self | ) |
Returns the number of columns in a Data Source
| def getNumberOfColumns | ( | self | ) |
getNumberOfColumns(DataSource self) -> size_t
| def getNumberOfColumns | ( | self | ) |
Returns the number of columns in the block
| def getNumberOfColumns | ( | self | ) |
Returns the number of columns in the block
| def getNumberOfDimensions | ( | self | ) |
Gets the number of dimensions in the Tensor
| def getNumberOfDims | ( | self | ) |
Returns the number of dimensions of the subtensor
| def getNumberOfFeatures | ( | self | ) |
Returns the number of features
| def getNumberOfFeatures | ( | self | ) |
Returns the number of features
| def getNumberOfRows | ( | self | ) |
Returns the number of rows in the Numeric Table
| def getNumberOfRows | ( | self | ) |
Returns the number of rows in the block
| def getNumberOfRows | ( | self | ) |
Returns the number of rows in the block
| def getNumericTable | ( | self | ) |
Returns a pointer to a Numeric Table associated with a Data Source
| def getNumericTable | ( | self | ) |
getNumericTable(DataSource self) -> daal.data_management.NumericTablePtr
| def getNumericTableAllocationFlag | ( | self | ) |
getNumericTableAllocationFlag(CsvDataSourceOptions self) -> daal.data_management.DataSource.NumericTableAllocationFlag
| def getNumericTableNumberOfColumns | ( | self | ) |
Returns the number of columns in a Numeric Table associated with a Data Source
| def getNumericTableNumberOfColumns | ( | self | ) |
getNumericTableNumberOfColumns(DataSource self) -> size_t
| def getNumericTableNumberOfColumns | ( | self | ) |
getNumericTableNumberOfColumns(CsvDataSource self) -> size_t
| def getOffsets | ( | self | ) |
Gets the offsets between adjacent elements in each dimension
| def getPackedArray | ( | self, | |
| args | |||
| ) |
Gets the whole packed array of a requested data type
| rwflag | Flag specifying read/write access to a block of feature vectors. |
| block | The block of feature values. |
Gets the whole packed array of a requested data type
| rwflag | Flag specifying read/write access to a block of feature vectors. |
| block | The block of feature values. |
Gets the whole packed array of a requested data type
| rwflag | Flag specifying read/write access to a block of feature vectors. |
| block | The block of feature values. |
| def getPackedArray | ( | self, | |
| args | |||
| ) |
getPackedArray(PackedSymmetricMatrix self, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getPackedArray | ( | self, | |
| args | |||
| ) |
getPackedArray(PackedTriangularMatrix self, daal.data_management.ReadWriteMode rwflag, BlockDescriptor block) -> Status
| def getParseHeaderFlag | ( | self | ) |
getParseHeaderFlag(CsvDataSourceOptions self) -> bool
| def getRangeDimIdx | ( | self | ) |
Gets values for the next dimension after fixed to get data from
| def getRangeDimNum | ( | self | ) |
Gets range for dimension values to get data from
| def getRowsOffset | ( | self | ) |
Gets the number of rows in the numeric table preceding the first element in the block
| def getRowsOffset | ( | self | ) |
getRowsOffset(CSRBlockDescriptor self) -> size_t
| def getRWFlag | ( | self | ) |
Gets the flag specifying read/write access to the block
| def getRWFlag | ( | self | ) |
getRWFlag(CSRBlockDescriptor self) -> size_t
| def getRWFlag | ( | self | ) |
Returns a flag specifying read/write access to the subtensor
| def getSampleTensor | ( | self, | |
| firstDimIndex | |||
| ) |
Returns new tensor with first dimension limited to one point
| firstDimIndex | Index of the point in the first dimention |
| def getSampleTensor | ( | self, | |
| firstDimIndex | |||
| ) |
getSampleTensor(HomogenTensor self, size_t firstDimIndex) -> daal.services.SharedPtr< daal.data_management.Tensor >
| def getSerializationTag | ( | self | ) |
Returns a serialization tag, a unique identifier of this class used in serialization
| def getSerializationTag | ( | self | ) |
getSerializationTag(DataCollection self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(DataSourceFeature self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(TensorOffsetLayout self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(AOSNumericTable self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(SOANumericTable self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(CSRNumericTable self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(MergedNumericTable self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(RowMergedNumericTable self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(NumericTableDictionary self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(DataSourceDictionary self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(HomogenNumericTable self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(HomogenTensor self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(Matrix self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(SerializableKeyValueCollection self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(PackedSymmetricMatrix self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(PackedTriangularMatrix self) -> int
| def getSerializationTag | ( | self | ) |
getSerializationTag(KeyValueDataCollection self) -> int
| def getSize | ( | self | ) |
getSize(DataBlock self) -> size_t
| def getSize | ( | self, | |
| args | |||
| ) |
Returns the full size of the tensor in number of elements
Returns the product of sizes of the range of dimensions
| startingIdx | The first dimension to include in the range |
| rangeSize | Number of dimensions to include in the range |
| def getSize | ( | self | ) |
Returns the full size of the subtensor in number of elements
| def getSizeOfArchive | ( | self | ) |
Returns the size of an archive
| def getSizeOfArchive | ( | self | ) |
getSizeOfArchive(DataArchive self) -> size_t
| def getSizeOfArchive | ( | self | ) |
getSizeOfArchive(CompressedDataArchive self) -> size_t
| def getSizeOfArchive | ( | self | ) |
getSizeOfArchive(DecompressedDataArchive self) -> size_t
| def getSizeOfArchive | ( | self | ) |
Returns the size of an archive
| def getSparseBlock | ( | self, | |
| args | |||
| ) |
Gets a block of feature vectors in the CSR layout.
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| rwflag | Flag specifying read/write access to the block of feature vectors. |
| block | The block of feature values. |
Gets a block of feature vectors in the CSR layout.
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| rwflag | Flag specifying read/write access to the block of feature vectors. |
| block | The block of feature values. |
Gets a block of feature vectors in the CSR layout.
| vector_idx | Index of the first row to include into the block. |
| vector_num | Number of rows in the block. |
| rwflag | Flag specifying read/write access to the block of feature vectors. |
| block | The block of feature values. |
| def getSparseBlock | ( | self, | |
| args | |||
| ) |
getSparseBlock(CSRNumericTable self, size_t vector_idx, size_t vector_num, daal.data_management.ReadWriteMode rwflag, CSRBlockDescriptor block) -> Status
| def getStatus | ( | self | ) |
Returns the status of a Data Source
| def getStatus | ( | self | ) |
getStatus(FileDataSource self) -> daal.data_management.DataSourceIface.DataSourceStatus
| def getStatus | ( | self | ) |
getStatus(StringDataSource self) -> daal.data_management.DataSourceIface.DataSourceStatus
| def getSubtensor | ( | self, | |
| args | |||
| ) |
Gets subtensor from the tensor
| fixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwflag | Flag specifying read/write access to the subtensor |
| subtensor | The subtensor descriptor. |
Gets subtensor from the tensor
| fixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwflag | Flag specifying read/write access to the subtensor |
| subtensor | The subtensor descriptor. |
Gets subtensor from the tensor
| fixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwflag | Flag specifying read/write access to the subtensor |
| subtensor | The subtensor descriptor. |
| def getSubtensor | ( | self, | |
| args | |||
| ) |
getSubtensor(HomogenTensor self, size_t fixedDims, size_t rangeDimIdx, size_t rangeDimNum, daal.data_management.ReadWriteMode rwflag, SubtensorDescriptor subtensor) -> Status
| def getSubtensorDimSizes | ( | self | ) |
Returns the array with sizes of dimensions of the subtensor
| def getSubtensorEx | ( | self, | |
| args | |||
| ) |
Gets subtensor from the tensor
| fixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwflag | Flag specifying read/write access to the subtensor |
| subtensor | The subtensor descriptor. |
| layout | Layout of the requested subtensor |
Gets subtensor from the tensor
| fixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwflag | Flag specifying read/write access to the subtensor |
| subtensor | The subtensor descriptor. |
| layout | Layout of the requested subtensor |
Gets subtensor from the tensor
| fixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwflag | Flag specifying read/write access to the subtensor |
| subtensor | The subtensor descriptor. |
| layout | Layout of the requested subtensor |
| def getSubtensorEx | ( | self, | |
| args | |||
| ) |
getSubtensorEx(HomogenTensor self, size_t fixedDims, size_t rangeDimIdx, size_t rangeDimNum, daal.data_management.ReadWriteMode rwflag, SubtensorDescriptor block, TensorOffsetLayout layout) -> Status
| def getTensorLayout | ( | self | ) |
Returns a homogeneous tensor offset layout
| def getUpdateVersion | ( | self | ) |
Returns the update version of the archive
| def getUpdateVersion | ( | self | ) |
getUpdateVersion(DataArchiveImpl self) -> int
| def getUpdateVersion | ( | self | ) |
Returns the update version of the library used for object serialization
| def getUsedOutputDataBlockSize | ( | self | ) |
Returns the number of bytes used after a call to the run() method
| def getUsedOutputDataBlockSize | ( | self | ) |
getUsedOutputDataBlockSize(Compression self) -> size_t
| def getValue_{Float64|Float32|Intc} | ( | self, | |
| args | |||
| ) |
Returns value by given column and row from the numeric table
| column | Column |
| row | Row |
Returns value by given column and row from the numeric table
| column | Column | |
| row | Row | |
| [in,out] | status | Status of the operation |
getValue_Float64 is for float64getValue_Float32 is for float32getValue_Intc is for intc | def getValueByIndex | ( | self, | |
| idx | |||
| ) |
Returns a reference to SharedPtr for a stored object with a given index
| idx | Index of the requested object |
| def getValueByIndexConst | ( | self, | |
| idx | |||
| ) |
Returns a const SharedPtr for a stored object with a given index
| idx | Index of the requested object |
| def daal.data_management.HomogenNumericTable_serializationTag | ( | ) |
| def daal.data_management.HomogenTensor_serializationTag | ( | ) |
| def isDefaultLayout | ( | self | ) |
isDefaultLayout(TensorOffsetLayout self) -> bool
| def isLayout | ( | self, | |
| layout | |||
| ) |
Checks if layout is equal to given
| layout | The layout type to compare with |
| def isNormalized | ( | self, | |
| flag | |||
| ) |
Checks if dataset stored in the numeric table is normalized, according to the given normalization flag
| flag | Normalization flag to check |
| def isOutputDataBlockFull | ( | self | ) |
Reports whether an output data block is full after a call to the run() method
| def isOutputDataBlockFull | ( | self | ) |
isOutputDataBlockFull(Compression self) -> bool
| def isRawLayout | ( | self | ) |
isRawLayout(TensorOffsetLayout self) -> bool
| def daal.data_management.KeyValueDataCollection_serializationTag | ( | ) |
| def list | ( | self, | |
| valid | |||
| ) |
list(ColumnFilter self, daal.services.Collection< size_t > valid) -> ColumnFilter
| def loadDataBlock | ( | self, | |
| args | |||
| ) |
Loads a data block of a specified size into an internally allocated Numeric Table
| maxRows | Maximum number of rows to load from a Data Source into the Numeric Table |
Loads a data block of a specified size into an internally allocated Numeric Table
| maxRows | Maximum number of rows to load from a Data Source into the Numeric Table |
| rowOffset | Write data starting from rowOffset row |
| fullRows | Maximum number of rows to allocate in the Numeric Table |
Loads a data block of a specified size into a provided Numeric Table
| maxRows | Maximum number of rows to load from a Data Source into the Numeric Table |
| nt | Pointer to the Numeric Table |
Loads a data block of a specified size into an internally allocated Numeric Table
| maxRows | Maximum number of rows to load from a Data Source into the Numeric Table |
| rowOffset | Write data starting from rowOffset row |
| fullRows | Maximum number of rows to allocate in the Numeric Table |
| nt | Pointer to the Numeric Table |
Loads a data block into an internally allocated Numeric Table
Loads a data block into a provided Numeric Table
| nt | Pointer to the Numeric Table |
| def loadDataBlock | ( | self, | |
| args | |||
| ) |
loadDataBlock(DataSource self, size_t maxRows) -> size_t
| def loadDataBlock | ( | self, | |
| args | |||
| ) |
loadDataBlock(CsvDataSource self, NumericTable nt) -> size_t
| def daal.data_management.Matrix_serializationTag | ( | ) |
Matrix_serializationTag() -> int
| def none | ( | self | ) |
none(ColumnFilter self) -> ColumnFilter
| def nullFunc | ( | word, | |
| aux, | |||
| arr | |||
| ) |
nullFunc(char const * word, FeatureAuxData aux, double * arr)
| def daal.data_management.NumericTableDictionary_create | ( | args | ) |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a data dictionary
| nfeat | Number of features in the table |
| featuresEqual | Flag specifying that all features have equal types and properties |
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
Constructs a default data dictionary
| stat | Status of the dictionary construction |
| def daal.data_management.NumericTableDictionary_serializationTag | ( | ) |
| def odd | ( | self | ) |
odd(ColumnFilter self) -> ColumnFilter
| def daal.data_management.PackedSymmetricMatrix_serializationTag | ( | ) |
| def daal.data_management.PackedTriangularMatrix_serializationTag | ( | ) |
| def parseRowAsDictionary | ( | self, | |
| rawRowData, | |||
| dict | |||
| ) |
Parses a string that represents features of a data set and constructs a dictionary
| rawRowData | Array of characters with a string that contains information about features of the data set |
| rawDataSize | Size of the rawRowData array |
| dict | Pointer to the dictionary constructed from the string |
| def parseRowIn | ( | self, | |
| rawRowData, | |||
| dict, | |||
| nt, | |||
| ntRowIndex | |||
| ) |
Parses a string that represents a feature vector and converts it into a numeric representation
| rawRowData | Array of characters with a string that represents the feature vector |
| rawDataSize | Size of the rawRowData array |
| dict | Pointer to the dictionary |
| nt | Pointer to a Numeric Table to store the result of parsing |
| ntRowIndex | Position in the Numeric Table at which to store the result of parsing |
| def push_back | ( | self, | |
| inBlock | |||
| ) |
Push a data to be compressed, accepts numpy byte array.
| inBlock | numpy byte array |
| def push_back | ( | self, | |
| inBlock | |||
| ) |
Push a data to be decompressed, accepts numpy byte array.
| inblock | numpy byte array |
| def push_back | ( | self, | |
| x | |||
| ) |
Adds an element to the end of a collection
| x | Element to add |
| def read | ( | self, | |
| ptr | |||
| ) |
Copies the content of an archive into a byte array
| ptr | Pointer to the array that represents the data |
| size | Size of the data array |
| def read | ( | self, | |
| ptr | |||
| ) |
read(DataArchive self, daal.byte * ptr)
| def read | ( | self, | |
| ptr | |||
| ) |
read(CompressedDataArchive self, daal.byte * ptr)
| def read | ( | self, | |
| ptr | |||
| ) |
read(DecompressedDataArchive self, daal.byte * ptr)
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
Releases a block of values for a given feature.
| block | The block of feature values. |
Releases a block of values for a given feature.
| block | The block of feature values. |
Releases a block of values for a given feature.
| block | The block of feature values. |
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(AOSNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(SOANumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(CSRNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(MergedNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(RowMergedNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(HomogenNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(PackedSymmetricMatrix self, BlockDescriptor block) -> Status
| def releaseBlockOfColumnValues | ( | self, | |
| args | |||
| ) |
releaseBlockOfColumnValues(PackedTriangularMatrix self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
Releases a block of rows.
| block | The block of rows. |
Releases a block of rows.
| block | The block of rows. |
Releases a block of rows.
| block | The block of rows. |
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(AOSNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(SOANumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(CSRNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(MergedNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(RowMergedNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(HomogenNumericTable self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(PackedSymmetricMatrix self, BlockDescriptor block) -> Status
| def releaseBlockOfRows | ( | self, | |
| args | |||
| ) |
releaseBlockOfRows(PackedTriangularMatrix self, BlockDescriptor block) -> Status
| def releasePackedArray | ( | self, | |
| args | |||
| ) |
Releases a packed array
| block | The block of feature values. |
Releases a packed array
| block | The block of feature values. |
Releases a packed array
| block | The block of feature values. |
| def releasePackedArray | ( | self, | |
| args | |||
| ) |
releasePackedArray(PackedSymmetricMatrix self, BlockDescriptor block) -> Status
| def releasePackedArray | ( | self, | |
| args | |||
| ) |
releasePackedArray(PackedTriangularMatrix self, BlockDescriptor block) -> Status
| def releaseSparseBlock | ( | self, | |
| args | |||
| ) |
Releases a block of feature vectors in the CSR layout.
| block | The block of feature values. |
Releases a block of feature vectors in the CSR layout.
| block | The block of feature values. |
Releases a block of feature vectors in the CSR layout.
| block | The block of feature values. |
| def releaseSparseBlock | ( | self, | |
| args | |||
| ) |
releaseSparseBlock(CSRNumericTable self, CSRBlockDescriptor block) -> Status
| def releaseSubtensor | ( | self, | |
| args | |||
| ) |
Releases subtensor
| subtensor | The subtensor descriptor. |
Releases subtensor
| subtensor | The subtensor descriptor. |
Releases subtensor
| subtensor | The subtensor descriptor. |
| def releaseSubtensor | ( | self, | |
| args | |||
| ) |
releaseSubtensor(HomogenTensor self, SubtensorDescriptor block) -> Status
| def reset | ( | self | ) |
Reset internal values and pointers to zero values
| def reset | ( | self | ) |
Reset internal values and pointers to zero values
| def reset | ( | self | ) |
Reset internal values and pointers to zero values
| def resetData | ( | self | ) |
Resets a data source string
| def resetDictionary | ( | self | ) |
Resets a data dictionary for the Numeric Table
| def resetDictionary | ( | self | ) |
resetDictionary(NumericTable self) -> Status
| def resetDictionary | ( | self | ) |
Resets a dictionary and sets the number of features to 0
| def resetDictionary | ( | self | ) |
Resets a dictionary and sets the number of features to 0
| def resize | ( | self, | |
| newCapacity | |||
| ) |
Changes the size of a storage
| newCapacity | Size of a new storage. |
| def resize | ( | self, | |
| nrows | |||
| ) |
Sets the number of rows in the Numeric Table and allocates memory for a data set
| def resize | ( | self, | |
| nrows | |||
| ) |
resize(NumericTable self, size_t nrows) -> Status
| def resize | ( | self, | |
| dimensions | |||
| ) |
resize(TensorIface self, daal.services.Collection< size_t > const & dimensions) -> Status
| def resize | ( | self, | |
| dimensions | |||
| ) |
resize(Tensor self, daal.services.Collection< size_t > const & dimensions) -> Status
| def resize | ( | self, | |
| nrows | |||
| ) |
resize(CSRNumericTable self, size_t nrows) -> Status
| def resize | ( | self, | |
| nrow | |||
| ) |
resize(MergedNumericTable self, size_t nrow) -> Status
| def resize | ( | self, | |
| nrows | |||
| ) |
resize(RowMergedNumericTable self, size_t nrows) -> Status
| def resizeBuffer | ( | self, | |
| nColumns, | |||
| nRows, | |||
auxMemorySize = 0 |
|||
| ) |
Allocates memory of (nColumns * nRows + auxMemorySize) size
| nColumns | Number of columns |
| nRows | Number of rows |
| auxMemorySize | Memory size |
Allocates memory of (nColumns * nRows + auxMemorySize) size
| nColumns | Number of columns |
| nRows | Number of rows |
| auxMemorySize | Memory size |
| def resizeBuffer | ( | self | ) |
Returns true if memory of (_subtensorSize) size is allocated successfully
| def resizeRowsBuffer | ( | self, | |
| nRows | |||
| ) |
| nRows | Number of rows |
| def resizeValuesBuffer | ( | self, | |
| nValues | |||
| ) |
| nValues | Number of values |
| def run | ( | self, | |
| outBlock, | |||
| offset | |||
| ) |
Performs compression (or decompression) of a data block
| outBlock | Pointer to the data block where compression (or decompression) results are stored. Must be at least size+offset bytes |
| size | Number of bytes available in outBlock |
| offset | Offset in bytes, the starting position for compression (or decompression) in outBlock |
| def run | ( | self, | |
| outBlock, | |||
| offset | |||
| ) |
run(Compression self, daal.byte * outBlock, size_t offset)
| def run | ( | self, | |
| outBlock, | |||
| offset | |||
| ) |
Performs bzip2 compression of a data block
| outBlock | Pointer to the data block where compression results are stored. Must be at least size+offset bytes |
| size | Number of bytes available in outBlock |
| offset | Offset in bytes, the starting position for compression in outBlock |
| def run | ( | self, | |
| outBlock, | |||
| offset | |||
| ) |
Performs bzip2 decompression of a data block
| outBlock | Pointer to the data block where decompression results are stored. Must be at least size+offset bytes |
| size | Number of bytes available in outBlock |
| offset | Offset in bytes, the starting position for decompression in outBlock |
| def saveOffsetLayout | ( | self, | |
| layout | |||
| ) |
Saves subtensor offset layout
| layout | offset layout |
| def saveOffsetLayoutCopy | ( | self, | |
| layout | |||
| ) |
Saves subtensor offset layout copy
| layout | offset layout |
| def segmentFooter | ( | self | ) |
Generates a footer for a segment in the DataArchive object
| def segmentFooter | ( | self | ) |
Reads the footer for a segment from the DataArchive object
| def segmentHeader | ( | self, | |
tag = 0 |
|||
| ) |
Generates a header for a segment in the DataArchive object
| def segmentHeader | ( | self | ) |
Reads the header for a segment from the DataArchive object
| def daal.data_management.SerializableKeyValueCollection_serializationTag | ( | ) |
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serializationTag | ( | ) |
serializationTag() -> int
| def serialize | ( | self, | |
| archive | |||
| ) |
Performs serialization
| archive | Storage for a serialized object or data structure |
| def set | ( | self, | |
| id, | |||
| value | |||
| ) |
set(BasicStatisticsDataCollection self, daal.data_management.NumericTableIface.BasicStatisticsId id, daal.services.SharedPtr< daal.data_management.NumericTable > const & value)
| def setAllFeatures | ( | self, | |
| defaultFeature | |||
| ) |
Sets all features of a dictionary to the same type
| defaultFeature | Default feature class to which to set all features |
| def setAllFeatures | ( | self, | |
| defaultFeature | |||
| ) |
Sets all features of a dictionary to the same type
| defaultFeature | Default feature class to which to set all features |
| def setArray | ( | self, | |
| outBlock | |||
| ) |
Sets array as block.
| def setArray | ( | self, | |
| ary, | |||
| idx | |||
| ) |
Sets numpy array to use.
| ary_ | numpy array which stores feature values |
| idx | Feature index |
| def setArrays | ( | self, | |
| args | |||
| ) |
| values | numpy array of double values in the CSR layout |
| colIndices | numpy array of column indices (long int) in the CSR layout |
| rowOffsets | numpy array of row indices (long int) in the CSR layout |
| values | numpy array of float values in the CSR layout |
| colIndices | numpy array of column indices (long int) in the CSR layout |
| rowOffsets | numpy array of row indices (long int) in the CSR layout |
| values | numpy array of int values in the CSR layout |
| colIndices | numpy array of column indices (long int) in the CSR layout |
| rowOffsets | numpy array of row indices (long int) in the CSR layout |
| def setCategoricalDictionary | ( | self, | |
| dictionary | |||
| ) |
setCategoricalDictionary(DataSourceFeature self, daal.data_management.CategoricalFeatureDictionaryPtr const & dictionary)
| def setData | ( | self, | |
| data | |||
| ) |
Sets a new string as a source for data
| data | Byte array in the C-string format |
| def setDetails | ( | self, | |
| columnIdx, | |||
| rowIdx, | |||
| rwFlag | |||
| ) |
Sets parameters of the block
| columnIdx | Index of the first column in the block |
| rowIdx | Index of the first row in the block |
| rwFlag | Flag specifying read/write access to the block |
| def setDetails | ( | self, | |
| nColumns, | |||
| rowIdx, | |||
| rwFlag | |||
| ) |
setDetails(CSRBlockDescriptor self, size_t nColumns, size_t rowIdx, int rwFlag)
| def setDetails | ( | self, | |
| tensorNDims, | |||
| tensorDimNums, | |||
| nFixedDims, | |||
| fixedDimNums, | |||
| rangeDimIdx, | |||
| rangeDimNum, | |||
| rwFlag | |||
| ) |
Sets subtensor parameters
| tensorNDims | The number of dimensions with fixed values |
| tensorDimNums | Values of the tensor dmensions |
| nFixedDims | The number of first dimension with fixed values |
| fixedDimNums | Values at which dimensions are fixed |
| rangeDimIdx | Values for the next dimension after fixed to get data from |
| rangeDimNum | Range for dimension values to get data from |
| rwFlag | Flag specifying read/write access to the subtensor |
| def setDictionary | ( | self, | |
| ddict | |||
| ) |
Sets a data dictionary in the Numeric Table
| ddict | Pointer to the data dictionary |
| def setDictionary | ( | self, | |
| ddict | |||
| ) |
setDictionary(NumericTable self, NumericTableDictionary ddict) -> Status
| def setDictionary | ( | self, | |
| ddict | |||
| ) |
setDictionary(SOANumericTable self, NumericTableDictionary ddict) -> Status
| def setDictionary | ( | self, | |
| dict | |||
| ) |
Sets a predefined Data Dictionary
| def setDictionary | ( | self, | |
| dict | |||
| ) |
setDictionary(DataSource self, DataSourceDictionary dict) -> Status
| def setDictionary | ( | self, | |
| dict | |||
| ) |
setDictionary(CsvDataSource self, DataSourceDictionary dict) -> Status
| def setDimensions | ( | self, | |
| args | |||
| ) |
| def setDimensions | ( | self, | |
| args | |||
| ) |
setDimensions(HomogenTensor self, size_t nDim, size_t const * dimSizes) -> Status
| def setFeature | ( | self, | |
| feature, | |||
| idx | |||
| ) |
| feature | Data feature |
| idx | Index of the data feature |
| def setFeature | ( | self, | |
| feature, | |||
| idx | |||
| ) |
| feature | Data feature |
| idx | Index of the data feature |
| def setFeatureName | ( | self, | |
| featureName | |||
| ) |
Specifies the name of a data feature
| featureName | Name of the data feature |
| def setInputDataBlock | ( | self, | |
| inBlock, | |||
| offset | |||
| ) |
Associates an input data block with a compressor (or decompressor)
| inBlock | Pointer to the data block to compress (or decompress). Must be at least size+offset bytes |
| size | Number of bytes to compress (or decompress) in inBlock |
| offset | Offset in bytes, the starting position for compression (or decompression) in inBlock |
| def setInputDataBlock | ( | self, | |
| inBlock, | |||
| offset | |||
| ) |
setInputDataBlock(Compression self, daal.byte * inBlock, size_t offset)
| def setInputDataBlock | ( | self, | |
| inBlock, | |||
| offset | |||
| ) |
Associates an input data block with a compressor
| inBlock | Pointer to the data block to compress. Must be at least size+offset bytes |
| size | Number of bytes to compress in inBlock |
| offset | Offset in bytes, the starting position for compression in inBlock |
| def setInputDataBlock | ( | self, | |
| inBlock, | |||
| offset | |||
| ) |
Associates an input data block with a decompressor
| inBlock | Pointer to the data block to decompress. Must be at least size+offset bytes |
| size | Number of bytes to decompress in inBlock |
| offset | Offset in bytes, the starting position for decompression in inBlock |
| def setMajorVersion | ( | self, | |
| majorVersion | |||
| ) |
Sets the major version of the archive
| majorVersion | The major version of the archive |
| def setMajorVersion | ( | self, | |
| majorVersion | |||
| ) |
setMajorVersion(DataArchiveImpl self, int majorVersion)
| def setMinorVersion | ( | self, | |
| minorVersion | |||
| ) |
Sets the minor version of the archive
| minorVersion | The minor version of the archive |
| def setMinorVersion | ( | self, | |
| minorVersion | |||
| ) |
setMinorVersion(DataArchiveImpl self, int minorVersion)
| def setNormalizationFlag | ( | self, | |
| flag | |||
| ) |
Sets the normalization flag for dataset stored in the numeric table
| flag | Normalization flag |
| def setNumberOfColumns | ( | self, | |
| ncol | |||
| ) |
Sets the number of columns in the Numeric Table
| ncol | Number of columns |
| def setNumberOfColumns | ( | self, | |
| ncol | |||
| ) |
setNumberOfColumns(NumericTable self, size_t ncol) -> Status
| def setNumberOfColumns | ( | self, | |
| nDim | |||
| ) |
setNumberOfColumns(PackedTriangularMatrix self, size_t nDim) -> Status
| def setNumberOfFeatures | ( | self, | |
| numberOfFeatures | |||
| ) |
Sets the number of features
| numberOfFeatures | Number of features |
| def setNumberOfFeatures | ( | self, | |
| numberOfFeatures | |||
| ) |
Sets the number of features
| numberOfFeatures | Number of features |
| def setNumberOfRows | ( | self, | |
| nrow | |||
| ) |
Sets the number of rows in the Numeric Table
| nrow | Number of rows |
| def setNumberOfRows | ( | self, | |
| nrow | |||
| ) |
setNumberOfRows(NumericTable self, size_t nrow) -> Status
| def setNumberOfRows | ( | self, | |
| nDim | |||
| ) |
setNumberOfRows(PackedTriangularMatrix self, size_t nDim) -> Status
| def setSingleObj | ( | self, | |
| ptr | |||
| ) |
Performs data serialization creating a data segment
| ptr | Pointer to the serializable object |
| def setSingleObj | ( | self, | |
| ptr | |||
| ) |
Performs data deserialization creating a data segment
| ptr | Pointer to the serializable object |
| def setType_{Float64|Float32|Intc} | ( | self | ) |
Fills the class based on a specified type
| T | Name of the data feature |
setType_Float64 is for float64setType_Float32 is for float32setType_Intc is for intc | def setUpdateVersion | ( | self, | |
| updateVersion | |||
| ) |
Sets the update version of the archive
| updateVersion | The update version of the archive |
| def setUpdateVersion | ( | self, | |
| updateVersion | |||
| ) |
setUpdateVersion(DataArchiveImpl self, int updateVersion)
| def shuffleDimensions | ( | self, | |
| dimsOrder | |||
| ) |
Sets the new order of existing dimension in the Tensor
| dimsOrder | Collection with the new indices for each dimension |
| def shuffleDimensions | ( | self, | |
| dimsOrder | |||
| ) |
shuffleDimensions(TensorOffsetLayout self, daal.services.Collection< size_t > const & dimsOrder) -> Status
| def size | ( | self | ) |
Size of a collection
| def size | ( | self | ) |
Returns the number of stored objects
| def sortOffsets | ( | self | ) |
sortOffsets(TensorOffsetLayout self) -> Status
| def status | ( | self | ) |
Returns errors during the computation
| def unite | ( | lhs, | |
| rhs | |||
| ) |
unite(daal.data_management.CsvDataSourceOptions.Value const & lhs, daal.data_management.CsvDataSourceOptions.Value const & rhs) -> daal.data_management.CsvDataSourceOptions.Value
| def write | ( | self, | |
| ptr | |||
| ) |
Copies data into an archive
| ptr | Pointer to the data represented in the byte format |
| size | Size of the data array |
| def write | ( | self, | |
| ptr | |||
| ) |
write(DataArchive self, daal.byte * ptr)
| def write | ( | self, | |
| ptr | |||
| ) |
write(CompressedDataArchive self, daal.byte * ptr)
| def write | ( | self, | |
| ptr | |||
| ) |
write(DecompressedDataArchive self, daal.byte * ptr)
|
static |
|
static |
|
static |
Counters estimate
|
static |
Memory will be allocated by NumericTable when needed
|
static |
Memory will be allocated by Tensor when needed
|
static |
Do allocate Numeric Table when needed
|
static |
Do create dictionary when needed
|
static |
Memory will not be allocated by NumericTable
|
static |
Memory will not be allocated by Tensor
|
static |
|
static |
No data is available
|
static |
Data Dictionary contains equal features
|
static |
|
static |
Memory allocated and managed by NumericTable
|
static |
Memory allocated and managed by Tensor
|
static |
Compression level
|
static |
Maximum estimate
|
static |
Minimum estimate
|
static |
Min-max normalization
|
static |
|
static |
|
static |
|
static |
Default: non-normalized
|
static |
Memory will not be allocated by NumericTable
Use doNotAllocate instead.
|
static |
Memory will not be allocated by Tensor
Use doNotAllocate instead.
|
static |
No memory allocated
|
static |
No memory allocated
|
static |
Do not allocate Numeric Table automatically
|
static |
Do not create dictionary automatically
|
static |
Data Dictionary contains different features
|
static |
DataSource not ready for loading
|
static |
|
static |
|
static |
1-based indexing
|
static |
Size in bytes of section 1 of the LZO compressed block header
|
static |
Data is ready to be loaded via loadDataBlock() function
|
static |
Standard score normalization (mean=0, variance=1)
|
static |
Sum estimate
|
static |
Sum squares estimate
|
static |
Memory allocated on user side
|
static |
Memory allocated on user side
|
static |
No data is available, but it may be ready in future
|
static |
|
static |
0-based indexing
For more complete information about compiler optimizations, see our Optimization Notice.