catboost 1.25.1 → 1.26.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.7/libcatboostmodel-linux-x86_64-1.2.7.so",
+   "sha256": "d27a19c49a40626573f5b06c04762f3d9daafb79a667b4ac3b291d6988be5e58",
    "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.7/libcatboostmodel-linux-aarch64-1.2.7.so",
+   "sha256": "ea9a9b590d6630bdc122b03cda1ae02c9de354a3ad27d3ada432d097eafeea92",
+   "targetFile": "libcatboostmodel.so"
+  }
+ ],
+ "darwin-universal2": [
+  {
+   "url": "https:/github.com/catboost/catboost/releases/download/v1.2.7/libcatboostmodel-darwin-universal2-1.2.7.dylib",
+   "sha256": "9a61ede2b7b955d08b29b03e54f3f9a6e4d36b4e006a92ec0b56867cbb5a0eac",
    "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.7/catboostmodel-windows-x86_64-1.2.7.dll",
+   "sha256": "9953ad56abe7e8a46f8eb046f38275b1238e4b24a3f76593f3de87a7586f9077",
    "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.7/catboostmodel-windows-x86_64-1.2.7.lib",
+   "sha256": "1d836f43e74f2165a02590987047a5e017d9be0c4376fed2002b672be0b600e6",
    "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 7
+
 #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,
 };
 
 /**
@@ -90,14 +103,35 @@ CATBOOST_API bool LoadFullModelFromBuffer(
     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 +139,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 +152,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 +240,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 +291,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 +406,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 +458,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 +497,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 +531,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 +564,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 +634,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 +661,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