catboost 1.25.1 → 1.26.0

package/lib/catboost.d.ts

@@ -1,31 +1,75 @@
-/** CatBoost numeric features for multiple documents. */
+/** CatBoost numeric features for multiple samples. */
 export type CatBoostFloatFeatures = Array<number[]>;
 /**
- * CatBoost categorial features for multiple documents - either integer hashes
+ * CatBoost categorical features for multiple samples - either integer hashes
  * or string values.
  */
 export type CatBoostCategoryFeatures = Array<number[]>|Array<string[]>;
+/** CatBoost text features for multiple samples. */
+export type CatBoostTextFeatures = Array<string[]>;
+/** CatBoost embedding features for multiple samples. */
+export type CatBoostEmbeddingFeatures = Array<Array<number[]>>;
 
 /** CatBoost model instance. */
 export class Model {
-	constructor(path?: string);
+    constructor(path?: string);
 
-	/** Loads model from file. */
-	loadModel(path: string): void;
-	/**
-	 * Calculate prediction for multiple documents.
-	 * The same number of numeric and categorial features is expected.
-	 */
-	predict(floatFeatures: CatBoostFloatFeatures,
-		catFeatures: CatBoostCategoryFeatures): number[];
-	/** Enable evaluation on GPU device. */
-	enableGPUEvaluation(deviceId: number): void;
-	/** The number of numeric features. */
-	getFloatFeaturesCount(): number;
-	/** The number of categorial features. */
-	getCatFeaturesCount(): number;
-	/** The number of trees in the model. */
-	getTreeCount(): number;
-	/** The number of dimensions in the model. */
-	getDimensionsCount(): number;
+	/** Load a model from the file. */
+    loadModel(path: string): void;
+    /** Set model prediction postprocessing type. Possible value are:
+     * RawFormulaVal - raw sum of leaf values for each dimension, this is the default
+     * Exponent - exp(sum(leaf values)),
+     * RMSEWithUncertainty - pair (prediction, uncertainty),
+     * Probability - (probablity for class_0, ..., probablity for class_i,...)
+     * MultiProbability - probability for each label (used for multilabel classification)
+     * Class - index of a class with the maximum predicted probability
+     * */
+    setPredictionType(predictionType: string): void;
+    /**
+     * Calculate the prediction for multiple samples.
+     * All defined feature arguments must have the same length.
+     *
+     * The returned value contains [sampleCount x predictionDimensions] elements
+     *  (should be accessed using [sampleIndex * predictionDimensions + predictionDimensionIdx],
+     *   for simple cases when predictionDimensions = 1 it is just [sampleIndex])
+     *  and its interpretation depends on prediction type (can be set with 'setPredictionType'):
+     *  - RawFormulaVal (this is the default):
+     *    array of raw sum of leaf values for each dimension
+     *  - Exponent:
+     *    array of exp(sum(leaf values)) for each dimension
+     *  - RMSEWithUncertainty:
+     *    array of pairs (prediction, uncertainty)
+     *  - Probability:
+     *    - for binary classification models:
+     *      array of probabilities for positive class (calculated as sigmoid(rawFormulaVal))
+     *    - for multiclassification models:
+     *      array of array of probabilities for each class (calculated as softmax(rawFormulaVal))
+     *  - MultiProbability:
+     *    array of probabilities for each label (calculated as sigmoid(rawFormulaVal))
+     *      (used for multilabel classification)
+     *  - Class:
+     *    array of predicted class indices.
+     *
+     * predictionDimensions can be obtained using 'getPredictionDimensionsCount' method.
+     */
+    predict(floatFeatures: CatBoostFloatFeatures,
+        catFeatures?: CatBoostCategoryFeatures,
+        textFeatures?: CatBoostTextFeatures,
+        embeddingFeatures?: CatBoostEmbeddingFeatures): number[];
+    /** Enable evaluation on GPU device. */
+    enableGPUEvaluation(deviceId: number): void;
+    /** The number of numeric features. */
+    getFloatFeaturesCount(): number;
+    /** The number of categorical features. */
+    getCatFeaturesCount(): number;
+    /** The number of text features. */
+    getTextFeaturesCount(): number;
+    /** The number of embedding features. */
+    getEmbeddingFeaturesCount(): number;
+    /** The number of trees in the model. */
+    getTreeCount(): number;
+    /** The number of dimensions in the model. */
+    getDimensionsCount(): number;
+    /** The number of dimensions in the prediction. */
+    getPredictionDimensionsCount(): number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catboost",
-  "version": "1.25.1",
+  "version": "1.26.0",
   "description": "Node bindings for CatBoost library to apply models. CatBoost is a machine learning method based on gradient boosting over decision trees.",
   "keywords": [
     "catboost",
@@ -16,11 +16,11 @@
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "dependencies": {
-    "node-addon-api": "^1.1.0"
+    "node-addon-api": "^8.2.2"
   },
   "scripts": {
     "install": "node ./build_scripts/bootstrap.js install",
-    "build": "node ./build_scripts/bootstrap.js build_ya",
+    "build": "node ./build_scripts/bootstrap.js build_native",
     "ci": "node ./build_scripts/bootstrap.js ci",
     "compile": "node ./build_scripts/bootstrap.js compile",
     "package_prepublish": "node ./build_scripts/bootstrap.js package_prepublish",
@@ -36,4 +36,4 @@
     "@types/node": "^7.10.14",
     "typescript": "^3.9.9"
   }
-}
+}

package/src/api_helpers.cpp

@@ -1,48 +1,124 @@
 #include "api_helpers.h"
 
-#include <util/system/yassert.h>
+#include <assert.h>
 
 namespace NHelper {
 
-bool IsMatrix(const Napi::Value& value, ENApiType type) {
-    if (!value.IsArray()) {
+bool CheckIsMatrix(Napi::Env env, const Napi::Value& value, ENApiType type, const std::string& errorPrefix) {
+    if (!Check(env, value.IsArray(), errorPrefix + "is not an array")) {
         return false;
     }
-    const Napi::Array floatFeatures = value.As<Napi::Array>();
-    const uint32_t rowsCount = floatFeatures.Length();
+    const Napi::Array matrix = value.As<Napi::Array>();
+    const uint32_t rowsCount = matrix.Length();
     if (rowsCount == 0) {
         return true;
     }
 
-    if (!floatFeatures[0u].IsArray()) {
+    if (!Check(env, matrix[0u].IsArray(), errorPrefix + "the first element of the matrix is not an array")) {
         return false;
     }
-    const uint32_t columnsCount = floatFeatures[0u].As<Napi::Array>().Length();
+    const uint32_t columnsCount = matrix[0u].As<Napi::Array>().Length();
+    size_t numberCount = 0;
+    size_t strCount = 0;
+
+    std::function<bool(const Napi::Value&)> checkElement;
+
+    switch (type) {
+        case ENApiType::NAT_NUMBER:
+            checkElement = [&] (const Napi::Value& value) -> bool {
+                return Check(
+                    env,
+                    value.IsNumber(),
+                    "non-numeric type in the matrix elements"
+                );
+            };
+            break;
+        case ENApiType::NAT_STRING:
+            checkElement = [&] (const Napi::Value& value) -> bool {
+                return Check(
+                    env,
+                    value.IsString(),
+                    "non-string type in the matrix elements"
+                );
+            };
+            break;
+        case ENApiType::NAT_NUMBER_OR_STRING:
+            checkElement = [&] (const Napi::Value& value) -> bool {
+                if (value.IsNumber()) {
+                    ++numberCount;
+                } else if (value.IsString()) {
+                    ++strCount;
+                } else {
+                    Check(env, false, errorPrefix + "invalid type found: " + std::to_string(value.Type()));
+                    return false;
+                }
+                return true;
+            };
+            break;
+        case ENApiType::NAT_ARRAY_OR_NUMBERS:
+            checkElement = [&] (const Napi::Value& value) -> bool {
+                if (!Check(
+                        env,
+                        value.IsArray(),
+                        "the matrix contains non-array elements"
+                    ))
+                {
+                    return false;
+                }
+
+                const Napi::Array subArray = value.As<Napi::Array>();
+                const uint32_t subArraySize = subArray.Length();
+
+                for (uint32_t k = 0; k < subArraySize; ++k) {
+                    if (!Check(
+                            env,
+                            subArray[k].IsNumber(),
+                            "an array in the matrix element contains a non-number element"
+                        ))
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            break;
+    }
+
 
     for (uint32_t i = 0; i < rowsCount; ++i) {
-        if (!floatFeatures[i].IsArray()) {
+        if (!Check(
+                env,
+                matrix[i].IsArray(),
+                errorPrefix + std::to_string(i) + "-th element of the matrix is not an array"
+            ))
+        {
             return false;
         }
 
-        const Napi::Array row = floatFeatures[i].As<Napi::Array>();
-        if (row.Length() != columnsCount) {
+        const Napi::Array row = matrix[i].As<Napi::Array>();
+        if (!Check(
+                env,
+                row.Length() == columnsCount,
+                errorPrefix + "invalid length of " + std::to_string(i) + "-th row"
+            ))
+        {
             return false;
         }
 
-        for (uint32_t j = 0; j < rowsCount; ++j) {
-            switch (type) {
-                case ENApiType::NAT_NUMBER:
-                    if (!row[j].IsNumber()) {
-                        return false;
-                    }
-                    break;
-                case ENApiType::NAT_STRING:
-                    if (!row[j].IsString()) {
-                        return false;
-                    }
-                    break;
-                default:
-                    Y_ASSERT(false);
+        for (uint32_t j = 0; j < columnsCount; ++j) {
+            if (!checkElement(row[j])) {
+                return false;
+            }
+        }
+
+        if (type == ENApiType::NAT_NUMBER_OR_STRING) {
+            if (!Check(
+                    env,
+                    !(numberCount > 0 && strCount > 0),
+                    errorPrefix + "mixed strings and numbers in the matrix"
+                ))
+            {
+                return false;
             }
         }
     }

package/src/api_helpers.h

@@ -4,11 +4,11 @@
 #include <napi.h>
 
 // Catboost C API
-#include <c_api.h>
+#include <catboost/libs/model_interface/c_api.h>
 
-#include <util/generic/vector.h>
+#include <vector>
 
-// Using STD version of string as it is used by N-API.
+// used by N-API.
 #include <string>
 
 namespace NHelper {
@@ -17,8 +17,7 @@ namespace NHelper {
 // Returns false if check failed.
 inline bool Check(Napi::Env env, bool condition, const std::string& message) {
     if (!condition) {
-        Napi::TypeError::New(env, message)
-	    .ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, message).ThrowAsJavaScriptException();
     }
 
     return condition;
@@ -50,14 +49,16 @@ inline bool CheckStatus(Napi::Env& env, bool status) {
 enum ENApiType {
     NAT_NUMBER,
     NAT_STRING,
+    NAT_NUMBER_OR_STRING,
+    NAT_ARRAY_OR_NUMBERS
 };
 
 // Checks if the value a matrix with element of a given type.
-bool IsMatrix(const Napi::Value& value, ENApiType type);
+bool CheckIsMatrix(Napi::Env env, const Napi::Value& value, ENApiType type, const std::string& errorStr);
 
 // Converts vector of numbers to N-API array.
 template <typename T>
-Napi::Array ConvertToArray(Napi::Env env, const TVector<T>& values) {
+Napi::Array ConvertToArray(Napi::Env env, const std::vector<T>& values) {
     Napi::Array result = Napi::Array::New(env);
     uint32_t index = 0;
     for (const auto value: values) {

package/src/api_module.cpp

@@ -3,8 +3,7 @@
 #include <napi.h>
 
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
-    exports.Set(Napi::String::New(env, "Model"),
-		            NNodeCatBoost::TModel::GetClass(env));
+    exports.Set(Napi::String::New(env, "Model"), NNodeCatBoost::TModel::GetClass(env));
     return exports;
 }