catboost 1.25.1 → 1.27.0

package/build_scripts/out/packaging.js

@@ -41,20 +41,6 @@ var fs_1 = require("fs");
 var download_1 = require("./download");
 var path_1 = require("path");
 var config_1 = require("./config");
-function copyHeadersRecursively(srcPath, targetPath) {
-    for (var _i = 0, _a = fs_1.readdirSync(srcPath); _i < _a.length; _i++) {
-        var part = _a[_i];
-        var path = path_1.join(srcPath, part);
-        var target = path_1.join(targetPath, part);
-        if (fs_1.lstatSync(path).isDirectory()) {
-            copyHeadersRecursively(path, target);
-            continue;
-        }
-        if (path_1.extname(path) === '.h') {
-            download_1.copyFile(path, target);
-        }
-    }
-}
 function prepareHeaders() {
     var incDir = './inc';
     if (!fs_1.existsSync(incDir)) {
@@ -63,10 +49,6 @@ function prepareHeaders() {
     var rootPath = '../..';
     var cApiPath = 'catboost/libs/model_interface/c_api.h';
     download_1.copyFile(path_1.join(rootPath, cApiPath), path_1.join(incDir, cApiPath));
-    var stlfwdPath = 'contrib/libs/cxxsupp/system_stl/include/stlfwd';
-    download_1.copyFile(path_1.join(rootPath, stlfwdPath), path_1.join(incDir, stlfwdPath));
-    var utilPath = 'util';
-    copyHeadersRecursively(path_1.join(rootPath, utilPath), path_1.join(incDir, utilPath));
 }
 exports.prepareHeaders = prepareHeaders;
 function generateConfigForVersion(version) {
@@ -75,7 +57,7 @@ function generateConfigForVersion(version) {
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    console.log("Preparing config for verion " + version);
+                    console.log("Preparing config for version " + version);
                     return [4 /*yield*/, config_1.createConfigForVersion(version)];
                 case 1:
                     _a = _b.sent(), config = _a[0], error = _a[1];

package/build_scripts/out/run_tests.js

@@ -45,7 +45,7 @@ function allTests() {
                 case 0: return [4 /*yield*/, build_1.compileBindings()];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, test_1.test()];
+                    return [4 /*yield*/, test_1.test(process.argv.indexOf('--have-cuda') > -1)];
                 case 2:
                     _a.sent();
                     return [2 /*return*/];

package/build_scripts/out/test.js

@@ -38,13 +38,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = void 0;
 var common_1 = require("./common");
-function test() {
+function test(haveCuda) {
     var _a;
     return __awaiter(this, void 0, void 0, function () {
-        var result;
+        var cmd, result;
         return __generator(this, function (_b) {
             switch (_b.label) {
-                case 0: return [4 /*yield*/, common_1.execProcess('node ./lib/tests/model.js')];
+                case 0:
+                    cmd = 'node ./lib/tests/model.js';
+                    if (haveCuda) {
+                        cmd += ' --have-cuda';
+                    }
+                    return [4 /*yield*/, common_1.execProcess(cmd)];
                 case 1:
                     result = _b.sent();
                     if (result.code !== 0) {

package/config.json

@@ -1,27 +1,34 @@
 {
- "linux": [
+ "linux-x64": [
   {
-   "url": "https:/github.com/catboost/catboost/releases/download/v0.25.1/libcatboostmodel.so",
-   "sha256": "ebc47ea32da1473220930014e1c705c07e7d60eda356325fabef691cd7ca8ab3",
+   "url": "https:/github.com/catboost/catboost/releases/download/v1.2.10/libcatboostmodel-linux-x86_64-1.2.10.so",
+   "sha256": "de32f8e147ee8f969599a00b7145e8561b943e916b0132b811037f8f71952a0e",
    "targetFile": "libcatboostmodel.so"
   }
  ],
- "mac": [
+ "linux-arm64": [
   {
-   "url": "https:/github.com/catboost/catboost/releases/download/v0.25.1/libcatboostmodel.dylib",
-   "sha256": "47e92550090944cdcd0af8157b7dc198fd04cc814d9662c99160bd6b227d63bb",
+   "url": "https:/github.com/catboost/catboost/releases/download/v1.2.10/libcatboostmodel-linux-aarch64-1.2.10.so",
+   "sha256": "d1b5d12f57ef72fd43505d9fbc1ea30d93d54ef0f305484c6bbfde8642e99a5b",
+   "targetFile": "libcatboostmodel.so"
+  }
+ ],
+ "darwin-universal2": [
+  {
+   "url": "https:/github.com/catboost/catboost/releases/download/v1.2.10/libcatboostmodel-darwin-universal2-1.2.10.dylib",
+   "sha256": "c31067d8df69e0be3dd353a06853d64f2e74bab1097512fc2d0db76add75514e",
    "targetFile": "libcatboostmodel.dylib"
   }
  ],
- "win": [
+ "win32-x64": [
   {
-   "url": "https:/github.com/catboost/catboost/releases/download/v0.25.1/catboostmodel.dll",
-   "sha256": "388921ad26d36a5fe865bf446f42a9f9e1e84fed3d2c0e104c4a777880bd6b27",
+   "url": "https:/github.com/catboost/catboost/releases/download/v1.2.10/catboostmodel-windows-x86_64-1.2.10.dll",
+   "sha256": "668d8867940a0832accaad6004e249f11ecc48eb63eb1d65551cfdd37c1939ad",
    "targetFile": "catboostmodel.dll"
   },
   {
-   "url": "https:/github.com/catboost/catboost/releases/download/v0.25.1/catboostmodel.lib",
-   "sha256": "b0acab2cf28bfcdd5e5a47be3c0e54a0bbb27f9c6efaff17d4fa2ee0a315b65b",
+   "url": "https:/github.com/catboost/catboost/releases/download/v1.2.10/catboostmodel-windows-x86_64-1.2.10.lib",
+   "sha256": "59b77bef6058548991d5eb942958999e0c3c21145f86bf0338d8f765d9975e9f",
    "targetFile": "catboostmodel.lib"
   }
  ]

package/inc/catboost/libs/model_interface/c_api.h

@@ -3,6 +3,11 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+
+#define CATBOOST_APPLIER_MAJOR 1
+#define CATBOOST_APPLIER_MINOR 2
+#define CATBOOST_APPLIER_FIX 10
+
 #if defined(__cplusplus)
 extern "C" {
 #endif
@@ -36,6 +41,8 @@ CATBOOST_API void AddCatFeatures(DataWrapperHandle* dataWrapperHandle, const cha
 
 CATBOOST_API void AddTextFeatures(DataWrapperHandle* dataWrapperHandle, const char*** textFeatures, size_t textFeaturesSize);
 
+CATBOOST_API void AddEmbeddingFeatures(DataWrapperHandle* dataWrapperHandle, const float*** embeddingFeatures, size_t* embeddingDimensions, size_t embeddingFeaturesSize);
+
 CATBOOST_API DataProviderHandle* BuildDataProvider(DataWrapperHandle* dataWrapperHandle);
 
 typedef void ModelCalcerHandle;
@@ -46,6 +53,12 @@ enum EApiPredictionType {
     APT_RMSE_WITH_UNCERTAINTY = 2,
     APT_PROBABILITY = 3,
     APT_CLASS = 4,
+    APT_MULTI_PROBABILITY = 5,
+};
+
+enum ECatBoostApiFormulaEvaluatorType {
+    CBA_FET_CPU = 0,
+    CBA_FET_GPU = 1,
 };
 
 /**
@@ -63,14 +76,17 @@ CATBOOST_API void ModelCalcerDelete(ModelCalcerHandle* modelHandle);
 /**
  * If error occured will return stored exception message.
  * If no error occured, will return invalid pointer
- * @return
+ * The underlying variable is thread-local so:
+ *  - it is thread-safe to get it
+ *  - indicates only errors that happened in the current thread
+ * @return Error message string. Uses UTF-8 encoding
  */
 CATBOOST_API const char* GetErrorString();
 
 /**
  * Load model from file into given model handle
  * @param calcer
- * @param filename
+ * @param filename path to the file. Uses UTF-8 encoding
  * @return false if error occured
  */
 CATBOOST_API bool LoadFullModelFromFile(
@@ -89,15 +105,49 @@ CATBOOST_API bool LoadFullModelFromBuffer(
     const void* binaryBuffer,
     size_t binaryBufferSize);
 
+
+/**
+ * Use model directly from given memory region with zero-copy method
+ * @param calcer
+ * @param binaryBuffer pointer to a memory buffer where model file is mapped
+ * @param binaryBufferSize size of the buffer in bytes
+ * @return false if error occured
+ */
+CATBOOST_API bool LoadFullModelZeroCopy(
+    ModelCalcerHandle* modelHandle,
+    const void* binaryBuffer,
+    size_t binaryBufferSize);
+
 /**
- * Use CUDA gpu device for model evaluation
+ * Use CUDA GPU device for model evaluation
 */
 CATBOOST_API bool EnableGPUEvaluation(ModelCalcerHandle* modelHandle, int deviceId);
 
+/**
+ * Get supported formula evaluator types
+ * formulaEvaluatorTypes array must be deallocated using free() after use.
+ *
+ * @param modelHandle model handle
+ * @param formulaEvaluatorTypes address of the pointer to an array that will be initialized with formula evaluator types
+ * @param formulaEvaluatorTypesCount address of the variable where the size of formulaEvaluatorTypes array will be stored
+ * @return true on success, false on error
+ */
+CATBOOST_API bool GetSupportedEvaluatorTypes(
+    ModelCalcerHandle* modelHandle,
+    enum ECatBoostApiFormulaEvaluatorType** formulaEvaluatorTypes,
+    size_t* formulaEvaluatorTypesCount);
+
+
 /**
  * Set prediction type for model evaluation
 */
-CATBOOST_API bool SetPredictionType(ModelCalcerHandle* modelHandle, EApiPredictionType predictionType);
+CATBOOST_API bool SetPredictionType(ModelCalcerHandle* modelHandle, enum EApiPredictionType predictionType);
+
+/**
+ * Set prediction type for model evaluation with string constant
+*/
+CATBOOST_API bool SetPredictionTypeString(ModelCalcerHandle* modelHandle, const char* predictionTypeStr);
+
 
 /**
  * **Use this method only if you really understand what you want.**
@@ -105,7 +155,7 @@ CATBOOST_API bool SetPredictionType(ModelCalcerHandle* modelHandle, EApiPredicti
  * Flat here means that float features and categorical feature are in the same float array.
  * @param calcer model handle
  * @param docCount number of objects
- * @param floatFeatures array of array of float (first dimension is object index, second if feature index)
+ * @param floatFeatures array of array of float (first dimension is object index, second is feature index)
  * @param floatFeaturesSize float values array size
  * @param result pointer to user allocated results vector
  * @param resultSize Result size should be equal to modelApproxDimension * docCount
@@ -118,6 +168,73 @@ CATBOOST_API bool CalcModelPredictionFlat(
     const float** floatFeatures, size_t floatFeaturesSize,
     double* result, size_t resultSize);
 
+
+/**
+ * **Use this method only if you really understand what you want.**
+ * Calculate raw model predictions on flat feature vectors
+ * taking into consideration only the trees in the range [treeStart; treeEnd)
+ * Flat here means that float features and categorical feature are in the same float array.
+ * @param calcer model handle
+ * @param docCount number of objects
+ * @param treeStart the index of the first tree to be used when applying the model (zero-based)
+ * @param treeEnd the index of the last tree to be used when applying the model (non-inclusive, zero-based)
+ * @param floatFeatures array of array of float (first dimension is object index, second is feature index)
+ * @param floatFeaturesSize float values array size
+ * @param result pointer to user allocated results vector
+ * @param resultSize Result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionFlatStaged(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    size_t treeStart, size_t treeEnd,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    double* result, size_t resultSize);
+
+
+/**
+ * **Use this method only if you really understand what you want.**
+ * Calculate raw model predictions on transposed dataset layout
+ * @param calcer model handle
+ * @param docCount number of objects
+ * @param floatFeatures array of array of float (first dimension is feature index, second is object index)
+ * @param floatFeaturesSize float values array size
+ * @param result pointer to user allocated results vector
+ * @param resultSize Result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionFlatTransposed(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    double* result, size_t resultSize);
+
+
+/**
+ * **Use this method only if you really understand what you want.**
+ * Calculate raw model predictions on transposed dataset layout
+ * taking into consideration only the trees in the range [treeStart; treeEnd)
+ * @param calcer model handle
+ * @param docCount number of objects
+ * @param treeStart the index of the first tree to be used when applying the model (zero-based)
+ * @param treeEnd the index of the last tree to be used when applying the model (non-inclusive, zero-based)
+ * @param floatFeatures array of array of float (first dimension is feature index, second is object index)
+ * @param floatFeaturesSize float values array size
+ * @param result pointer to user allocated results vector
+ * @param resultSize Result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionFlatTransposedStaged(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    size_t treeStart, size_t treeEnd,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    double* result, size_t resultSize);
+
+
 /**
  * Calculate raw model predictions on float features and string categorical feature values
  * @param calcer model handle
@@ -139,6 +256,32 @@ CATBOOST_API bool CalcModelPrediction(
     const char*** catFeatures, size_t catFeaturesSize,
     double* result, size_t resultSize);
 
+/**
+ * Calculate raw model predictions on float features and string categorical feature values
+ * taking into consideration only the trees in the range [treeStart; treeEnd)
+ * @param calcer model handle
+ * @param docCount object count
+ * @param treeStart the index of the first tree to be used when applying the model (zero-based)
+ * @param treeEnd the index of the last tree to be used when applying the model (non-inclusive, zero-based)
+ * @param floatFeatures array of array of float (first dimension is object index, second is feature index)
+ * @param floatFeaturesSize float feature count
+ * @param catFeatures array of array of char* categorical value pointers.
+ * String pointer should point to zero terminated string.
+ * @param catFeaturesSize categorical feature count
+ * @param result pointer to user allocated results vector
+ * @param resultSize result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionStaged(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    size_t treeStart, size_t treeEnd,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const char*** catFeatures, size_t catFeaturesSize,
+    double* result, size_t resultSize);
+
+
 /**
  * Calculate raw model predictions on float features and string categorical feature values
  * @param calcer model handle
@@ -164,6 +307,101 @@ CATBOOST_API bool CalcModelPredictionText(
     const char*** textFeatures, size_t textFeaturesSize,
     double* result, size_t resultSize);
 
+
+/**
+ * Calculate raw model predictions on float features and string categorical feature values
+ * taking into consideration only the trees in the range [treeStart; treeEnd)
+ * @param calcer model handle
+ * @param docCount object count
+ * @param treeStart the index of the first tree to be used when applying the model (zero-based)
+ * @param treeEnd the index of the last tree to be used when applying the model (non-inclusive, zero-based)
+ * @param floatFeatures array of array of float (first dimension is object index, second is feature index)
+ * @param floatFeaturesSize float feature count
+ * @param catFeatures array of array of char* categorical value pointers.
+ * String pointer should point to zero terminated string.
+ * @param catFeaturesSize categorical feature count
+ * @param textFeatures array of array of char* text value pointers.
+ * String pointer should point to zero terminated string.
+ * @param textFeaturesSize text feature count
+ * @param result pointer to user allocated results vector
+ * @param resultSize result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionTextStaged(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    size_t treeStart, size_t treeEnd,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const char*** catFeatures, size_t catFeaturesSize,
+    const char*** textFeatures, size_t textFeaturesSize,
+    double* result, size_t resultSize);
+
+
+/**
+ * Calculate raw model predictions on float features and string categorical feature values
+ * @param calcer model handle
+ * @param docCount object count
+ * @param floatFeatures array of array of float (first dimension is object index, second is feature index)
+ * @param floatFeaturesSize float feature count
+ * @param catFeatures array of array of char* categorical value pointers.
+ * String pointer should point to zero terminated string.
+ * @param catFeaturesSize categorical feature count
+ * @param textFeatures array of array of char* text value pointers.
+ * String pointer should point to zero terminated string.
+ * @param textFeaturesSize text feature count
+ * @param embeddingFeatures array of array of array of float (first dimension is object index, second is feature index, third is index in embedding array).
+ * String pointer should point to zero terminated string.
+ * @param embeddingFeaturesSize embedding feature count
+ * @param result pointer to user allocated results vector
+ * @param resultSize result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionTextAndEmbeddings(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const char*** catFeatures, size_t catFeaturesSize,
+    const char*** textFeatures, size_t textFeaturesSize,
+    const float*** embeddingFeatures, size_t* embeddingDimensions, size_t embeddingFeaturesSize,
+    double* result, size_t resultSize);
+
+
+/**
+ * Calculate raw model predictions on float features and string categorical feature values
+ * taking into consideration only the trees in the range [treeStart; treeEnd)
+ * @param calcer model handle
+ * @param docCount object count
+ * @param treeStart the index of the first tree to be used when applying the model (zero-based)
+ * @param treeEnd the index of the last tree to be used when applying the model (non-inclusive, zero-based)
+ * @param floatFeatures array of array of float (first dimension is object index, second is feature index)
+ * @param floatFeaturesSize float feature count
+ * @param catFeatures array of array of char* categorical value pointers.
+ * String pointer should point to zero terminated string.
+ * @param catFeaturesSize categorical feature count
+ * @param textFeatures array of array of char* text value pointers.
+ * String pointer should point to zero terminated string.
+ * @param textFeaturesSize text feature count
+ * @param embeddingFeatures array of array of array of float (first dimension is object index, second is feature index, third is index in embedding array).
+ * String pointer should point to zero terminated string.
+ * @param embeddingFeaturesSize embedding feature count
+ * @param result pointer to user allocated results vector
+ * @param resultSize result size should be equal to modelApproxDimension * docCount
+ * (e.g. for non multiclass models should be equal to docCount)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionTextAndEmbeddingsStaged(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    size_t treeStart, size_t treeEnd,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const char*** catFeatures, size_t catFeaturesSize,
+    const char*** textFeatures, size_t textFeaturesSize,
+    const float*** embeddingFeatures, size_t* embeddingDimensions, size_t embeddingFeaturesSize,
+    double* result, size_t resultSize);
+
+
 /**
  * Calculate raw model prediction on float features and string categorical feature values for single object
  * @param calcer model handle
@@ -184,6 +422,30 @@ CATBOOST_API bool CalcModelPredictionSingle(
         double* result, size_t resultSize);
 
 
+/**
+ * Calculate raw model prediction on float features and string categorical feature values for single object
+ * taking into consideration only the trees in the range [treeStart; treeEnd)
+ * @param calcer model handle
+ * @param treeStart the index of the first tree to be used when applying the model (zero-based)
+ * @param treeEnd the index of the last tree to be used when applying the model (non-inclusive, zero-based)
+ * @param floatFeatures array of float features
+ * @param floatFeaturesSize float feature count
+ * @param catFeatures array of char* categorical feature value pointers.
+ * Each string pointer should point to zero terminated string.
+ * @param catFeaturesSize categorical feature count
+ * @param result pointer to user allocated results vector (or single double)
+ * @param resultSize result size should be equal to modelApproxDimension
+ * (e.g. for non multiclass models should be equal to 1)
+ * @return false if error occured
+ */
+CATBOOST_API bool CalcModelPredictionSingleStaged(
+        ModelCalcerHandle* modelHandle,
+        size_t treeStart, size_t treeEnd,
+        const float* floatFeatures, size_t floatFeaturesSize,
+        const char** catFeatures, size_t catFeaturesSize,
+        double* result, size_t resultSize);
+
+
 /**
  * Calculate raw model predictions on float features and hashed categorical feature values
  * @param calcer model handle
@@ -212,6 +474,15 @@ CATBOOST_API bool CalcModelPredictionWithHashedCatFeaturesAndTextFeatures(
     const char*** textFeatures, size_t textFeaturesSize,
     double* result, size_t resultSize);
 
+CATBOOST_API bool CalcModelPredictionWithHashedCatFeaturesAndTextAndEmbeddingFeatures(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const int** catFeatures, size_t catFeaturesSize,
+    const char*** textFeatures, size_t textFeaturesSize,
+    const float*** embeddingFeatures, size_t* embeddingDimensions, size_t embeddingFeaturesSize,
+    double* result, size_t resultSize);
+
 /**
  * Methods equivalent to the methods above
  * only returning a prediction for the specific class
@@ -242,6 +513,16 @@ CATBOOST_API bool PredictSpecificClassText(
     int classId,
     double* result, size_t resultSize);
 
+CATBOOST_API bool PredictSpecificClassTextAndEmbeddings(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const char*** catFeatures, size_t catFeaturesSize,
+    const char*** textFeatures, size_t textFeaturesSize,
+    const float*** embeddingFeatures, size_t* embeddingDimensions, size_t embeddingFeaturesSize,
+    int classId,
+    double* result, size_t resultSize);
+
 CATBOOST_API bool PredictSpecificClassSingle(
     ModelCalcerHandle* modelHandle,
     const float* floatFeatures, size_t floatFeaturesSize,
@@ -266,6 +547,16 @@ CATBOOST_API bool PredictSpecificClassWithHashedCatFeaturesAndTextFeatures(
     int classId,
     double* result, size_t resultSize);
 
+CATBOOST_API bool PredictSpecificClassWithHashedCatFeaturesAndTextAndEmbeddingFeatures(
+    ModelCalcerHandle* modelHandle,
+    size_t docCount,
+    const float** floatFeatures, size_t floatFeaturesSize,
+    const int** catFeatures, size_t catFeaturesSize,
+    const char*** textFeatures, size_t textFeaturesSize,
+    const float*** embeddingFeatures, size_t* embeddingDimensions, size_t embeddingFeaturesSize,
+    int classId,
+    double* result, size_t resultSize);
+
 /**
  * Get hash for given string value
  * @param data we don't expect data to be zero terminated, so pass correct size
@@ -289,12 +580,64 @@ CATBOOST_API int GetIntegerCatFeatureHash(long long val);
  */
 CATBOOST_API size_t GetFloatFeaturesCount(ModelCalcerHandle* modelHandle);
 
+/**
+ * Get expected indices of float features used in the model.
+ * indices array must be deallocated using free() after use.
+ * @param modelHandle model handle
+ * @param indices indices of the features
+ * @param count indices size
+ * @return true on success, false on error
+ */
+CATBOOST_API bool GetFloatFeatureIndices(ModelCalcerHandle* modelHandle, size_t** indices, size_t* count);
+
 /**
  * Get expected categorical feature count for model
  * @param calcer model handle
  */
 CATBOOST_API size_t GetCatFeaturesCount(ModelCalcerHandle* modelHandle);
 
+/**
+ * Get expected indices of category features used in the model.
+ * indices array must be deallocated using free() after use.
+ * @param modelHandle model handle
+ * @param indices indices of the features
+ * @param count indices size
+ * @return true on success, false on error
+ */
+CATBOOST_API bool GetCatFeatureIndices(ModelCalcerHandle* modelHandle, size_t** indices, size_t* count);
+
+/**
+ * Get expected text feature count for model
+ * @param calcer model handle
+ */
+CATBOOST_API size_t GetTextFeaturesCount(ModelCalcerHandle* modelHandle);
+
+/**
+ * Get expected indices of text features used in the model.
+ * indices array must be deallocated using free() after use.
+ * @param modelHandle model handle
+ * @param indices indices of the features
+ * @param count indices size
+ * @return true on success, false on error
+ */
+CATBOOST_API bool GetTextFeatureIndices(ModelCalcerHandle* modelHandle, size_t** indices, size_t* count);
+
+/**
+ * Get expected embedding feature count for model
+ * @param calcer model handle
+ */
+CATBOOST_API size_t GetEmbeddingFeaturesCount(ModelCalcerHandle* modelHandle);
+
+/**
+ * Get expected indices of embedding features used in the model.
+ * indices array must be deallocated using free() after use.
+ * @param modelHandle model handle
+ * @param indices indices of the features
+ * @param count indices size
+ * @return true on success, false on error
+ */
+CATBOOST_API bool GetEmbeddingFeatureIndices(ModelCalcerHandle* modelHandle, size_t** indices, size_t* count);
+
 /**
  * Get number of trees in model
  * @param calcer model handle
@@ -307,6 +650,15 @@ CATBOOST_API size_t GetTreeCount(ModelCalcerHandle* modelHandle);
  */
 CATBOOST_API size_t GetDimensionsCount(ModelCalcerHandle* modelHandle);
 
+/**
+ * Get number of dimensions for current prediction
+ * For default `APT_RAW_FORMULA_VAL`, `APT_EXPONENT`, `APT_PROBABILITY`, `APT_CLASS` prediction type GetPredictionDimensionsCount == GetDimensionsCount
+ * For `APT_RMSE_WITH_UNCERTAINTY` - returns 2 (value prediction and predicted uncertainty)
+ * @param calcer model handle
+ */
+CATBOOST_API size_t GetPredictionDimensionsCount(ModelCalcerHandle* modelHandle);
+
+
 /**
  * Check if model metadata holds some value for provided key
  * @param calcer model handle
@@ -325,6 +677,16 @@ CATBOOST_API size_t GetModelInfoValueSize(ModelCalcerHandle* modelHandle, const
  */
 CATBOOST_API const char* GetModelInfoValue(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize);
 
+
+/**
+ * Get names of features used in the model.
+ * individual strings in featureNames array and featureNames array itself must be deallocated using free() after use.
+ *
+ * @return true on success, false on error
+ */
+CATBOOST_API bool GetModelUsedFeaturesNames(ModelCalcerHandle* modelHandle, char*** featureNames, size_t* featureCount);
+
+
 #if defined(__cplusplus)
 }
 #endif