shevchenko/dist/cjs/anthroponym-declension/family-name-classifier/family-name-classifer.js

JavaScript library for declension of Ukrainian anthroponyms

/**
 * @file JavaScript library for declension of Ukrainian anthroponyms
 * @module shevchenko
 * @version 3.2.2
 * @author Oleksandr Tolochko <shevchenko-js@tooleks.com>
 * @license MIT
 * @copyright 2017-2026 Oleksandr Tolochko <shevchenko-js@tooleks.com>
 * @see {@link git+https://github.com/tooleks/shevchenko-js.git}
 */
'use strict';

var tf = require('@tensorflow/tfjs');
var incorrectPredictions = require('./cache/incorrect-predictions.json.js');
var familyNameClassTransformer = require('./family-name-class-transformer.js');
var modelConfig = require('./model-config.js');
var wordTransformer = require('./word-transformer.js');

function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n.default = e;
    return Object.freeze(n);
}

var tf__namespace = /*#__PURE__*/_interopNamespaceDefault(tf);

// Disable Node.js environment warning message in production code.
// See https://github.com/tensorflow/tfjs/issues/5349
tf__namespace.env().set('IS_NODE', false);
class FamilyNameClassifier {
    constructor(modelLoader) {
        this.modelLoader = modelLoader;
        this.modelPromise = null;
        this.wordTransformer = new wordTransformer.WordTransformer(modelConfig.MODEL_INPUT_SIZE);
        this.familyNameClassTransformer = new familyNameClassTransformer.FamilyNameClassTransformer();
    }
    /**
     * Classifies the word class of a given family name.
     */
    async classify(familyName) {
        let familyNameClass = this.getCached(familyName);
        if (familyNameClass != null) {
            return familyNameClass;
        }
        const model = await this.loadModel();
        const input = this.wordTransformer.encode(familyName);
        const output = await model.predict(tf__namespace.tensor2d([input])).data();
        familyNameClass = this.familyNameClassTransformer.decode(output);
        return familyNameClass;
    }
    /**
     * Returns a classified family name class from the cache if exists.
     */
    getCached(familyName) {
        let familyNameClass = null;
        const wordClass = incorrectPredictions.default[familyName.toLowerCase()];
        if (wordClass) {
            familyNameClass = { wordClass };
        }
        return familyNameClass;
    }
    /**
     * Loads the model from the storage. If called multiple times, resolves the same model instance.
     */
    async loadModel() {
        if (this.modelPromise == null) {
            this.modelPromise = tf__namespace.loadLayersModel(this.modelLoader);
        }
        return this.modelPromise;
    }
}

exports.FamilyNameClassifier = FamilyNameClassifier;