nlptoolkit-universaldependencyparser 1.0.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "nlptoolkit-universaldependencyparser",
+  "version": "1.0.0",
+  "description": "Dependency Parsing Algorithms",
+  "main": "index.js",
+  "types": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/StarlangSoftware/UniversalDependencyParser-Js.git"
+  },
+  "author": "Olcay Taner YILDIZ",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/StarlangSoftware/UniversalDependencyParser-Js/issues"
+  },
+  "homepage": "https://github.com/StarlangSoftware/UniversalDependencyParser-Js#readme",
+  "devDependencies": {
+    "@types/mocha": "^10.0.1",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "nlptoolkit-classification": "^1.0.7",
+    "nlptoolkit-dependencyparser": "^1.0.8"
+  }
+}

package/source/Parser/TransitionBasedParser/Agenda.ts

@@ -0,0 +1,66 @@
+import {State} from "./State";
+import {ScoringOracle} from "./ScoringOracle";
+
+export class Agenda {
+
+    private agenda: Map<State, number>
+    private beamSize: number
+
+    constructor(beamSize: number) {
+        this.agenda = new Map<State, number>()
+        this.beamSize = beamSize
+    }
+
+    /**
+     * Retrieves the set of states currently in the agenda.
+     * @return A set of states that are currently in the agenda.
+     */
+    getKeySet(): IterableIterator<State>{
+        return this.agenda.keys()
+    }
+
+    /**
+     * Updates the agenda with a new state if it is better than the worst state
+     * currently in the agenda or if there is room in the agenda.
+     * @param oracle The ScoringOracle used to score the state.
+     * @param current The state to be added to the agenda.
+     */
+    updateAgenda(oracle: ScoringOracle, current: State){
+        if (this.agenda.has(current)){
+            return
+        }
+        let point = oracle.score(current)
+        if (this.agenda.size < this.beamSize){
+            this.agenda.set(current, point)
+        } else{
+            let worst = null
+            let worstValue = Number.MAX_VALUE
+            for (let key of this.agenda.keys()){
+                if (this.agenda.get(key) < worstValue){
+                    worstValue = this.agenda.get(key)
+                    worst = key
+                }
+            }
+            if (point > worstValue){
+                this.agenda.delete(worst)
+                this.agenda.set(current, point)
+            }
+        }
+    }
+
+    /**
+     * Retrieves the best state from the agenda based on the highest score.
+     * @return The state with the highest score in the agenda.
+     */
+    best(): State{
+        let best = null
+        let bestValue = Number.MIN_VALUE
+        for (let key of this.agenda.keys()){
+            if (this.agenda.get(key) > bestValue){
+                bestValue = this.agenda.get(key)
+                best = key
+            }
+        }
+        return best
+    }
+}

package/source/Parser/TransitionBasedParser/ArcEagerInstanceGenerator.ts

@@ -0,0 +1,73 @@
+import {InstanceGenerator} from "./InstanceGenerator";
+import {State} from "./State";
+import {Instance} from "nlptoolkit-classification/dist/Instance/Instance";
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+import {DiscreteIndexedAttribute} from "nlptoolkit-classification/dist/Attribute/DiscreteIndexedAttribute";
+import {
+    UniversalDependencyTreeBankFeatures
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankFeatures";
+import {Attribute} from "nlptoolkit-classification/dist/Attribute/Attribute";
+
+export class ArcEagerInstanceGenerator extends InstanceGenerator{
+
+    /**
+     * Checks if the given word has a valid relation.
+     * @param word The UniversalDependencyTreeBankWord to check.
+     * @return true if the relation is valid, false otherwise.
+     */
+    private suitable(word: UniversalDependencyTreeBankWord): boolean{
+        return word.getRelation() != null
+    }
+
+    /**
+     * Generates an Instance object based on the provided state, window size, and command.
+     * The Instance is populated with attributes derived from the words in the state.
+     * @param state The state used to generate the instance.
+     * @param windowSize The size of the window used to extract words from the state.
+     * @param command The command associated with the instance.
+     * @return The generated Instance object.
+     */
+    generate(state: State, windowSize: number, command: string): Instance {
+        let instance = new Instance(command)
+        let attributes = new Array<Attribute>()
+        for (let i = 0; i < windowSize; i++) {
+            let word = state.getStackWord(i);
+            if (word == null) {
+                attributes.push(new DiscreteIndexedAttribute("null", 0, 18))
+                this.addEmptyAttributes(attributes)
+                attributes.push(new DiscreteIndexedAttribute("null", 0, 59))
+            } else {
+                if (word.getName() == "root") {
+                    attributes.push(new DiscreteIndexedAttribute("root", 0, 18))
+                    this.addEmptyAttributes(attributes)
+                    attributes.push(new DiscreteIndexedAttribute("null", 0, 59))
+                } else {
+                    attributes.push(new DiscreteIndexedAttribute(word.getUpos().toString(), UniversalDependencyTreeBankFeatures.posIndex(word.getUpos().toString()) + 1, 18))
+                    this.addFeatureAttributes(word, attributes)
+                    if (this.suitable(word)) {
+                        attributes.push(new DiscreteIndexedAttribute(word.getRelation().toString(), UniversalDependencyTreeBankFeatures.dependencyIndex(word.getRelation().toString()) + 1, 59))
+                    } else {
+                        attributes.push(new DiscreteIndexedAttribute("null", 0, 59))
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < windowSize; i++) {
+            let word = state.getWordListWord(i)
+            if (word != null) {
+                attributes.push(new DiscreteIndexedAttribute(word.getUpos().toString(), UniversalDependencyTreeBankFeatures.posIndex(word.getUpos().toString()) + 1, 18))
+                this.addFeatureAttributes(word, attributes)
+            } else {
+                attributes.push(new DiscreteIndexedAttribute("root", 0, 18))
+                this.addEmptyAttributes(attributes)
+            }
+        }
+        for (let attribute of attributes) {
+            instance.addAttribute(attribute)
+        }
+        return instance
+    }
+
+}

package/source/Parser/TransitionBasedParser/ArcEagerOracle.ts

@@ -0,0 +1,30 @@
+import {Oracle} from "./Oracle";
+import {State} from "./State";
+import {Decision} from "./Decision";
+import {Model} from "nlptoolkit-classification/dist/Model/Model";
+import {SimpleInstanceGenerator} from "./SimpleInstanceGenerator";
+
+export class ArcEagerOracle extends Oracle{
+
+    constructor(model: Model, windowSize: number) {
+        super(model, windowSize)
+    }
+
+    public makeDecision(state: State): Decision {
+        let instanceGenerator = new SimpleInstanceGenerator()
+        let instance = instanceGenerator.generate(state, this.windowSize, "");
+        let best = this.findBestValidEagerClassInfo(this.commandModel.predictProbability(instance), state)
+        let decisionCandidate = this.getDecisionCandidate(best)
+        if (decisionCandidate.getCommand() == Command.SHIFT) {
+            return new Decision(Command.SHIFT, null, 0.0)
+        } else if (decisionCandidate.getCommand() == Command.REDUCE) {
+            return new Decision(Command.REDUCE, null, 0.0)
+        }
+        return new Decision(decisionCandidate.getCommand(), decisionCandidate.getUniversalDependencyType(), 0.0)
+    }
+
+    protected scoreDecisions(state: State, transitionSystem: TransitionSystem): Array<Decision> {
+        return null;
+    }
+
+}

package/source/Parser/TransitionBasedParser/ArcEagerTransitionParser.ts

@@ -0,0 +1,105 @@
+import {TransitionParser} from "./TransitionParser";
+import {
+    UniversalDependencyTreeBankSentence
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankSentence";
+import {Instance} from "nlptoolkit-classification/dist/Instance/Instance";
+import {Oracle} from "./Oracle";
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+import {ArcEagerInstanceGenerator} from "./ArcEagerInstanceGenerator";
+import {StackWord} from "./StackWord";
+import {State} from "./State";
+import {StackRelation} from "./StackRelation";
+
+export class ArcEagerTransitionParser extends TransitionParser{
+
+    constructor() {
+        super()
+    }
+
+    dependencyParse(universalDependencyTreeBankSentence: UniversalDependencyTreeBankSentence, oracle: Oracle): UniversalDependencyTreeBankSentence {
+        let sentence = this.createResultSentence(universalDependencyTreeBankSentence)
+        let state = this.initialState(sentence)
+        while (state.wordListSize() > 0 || state.stackSize() > 1) {
+            let decision = oracle.makeDecision(state)
+            switch (decision.getCommand()) {
+                case Command.SHIFT:
+                    state.applyShift()
+                    break;
+                case Command.LEFTARC:
+                    state.applyArcEagerLeftArc(decision.getUniversalDependencyType())
+                    break;
+                case Command.RIGHTARC:
+                    state.applyArcEagerRightArc(decision.getUniversalDependencyType())
+                    break;
+                case Command.REDUCE:
+                    state.applyReduce()
+                    break;
+                default:
+                    break;
+            }
+        }
+        return sentence;
+    }
+
+    simulateParse(sentence: UniversalDependencyTreeBankSentence, windowSize: number): Array<Instance> {
+        let topRelation = null
+        let instanceGenerator = new ArcEagerInstanceGenerator()
+        let instanceList = new Array<Instance>()
+        let wordMap = new Map<number, UniversalDependencyTreeBankWord>()
+        let wordList = new Array<StackWord>()
+        let stack = new Array<StackWord>()
+        for (let j = 0; j < sentence.wordCount(); j++) {
+            let word = sentence.getWord(j);
+            if (word instanceof UniversalDependencyTreeBankWord){
+                let clone = word.clone()
+                clone.setRelation(null)
+                wordMap.set(j + 1, word)
+                wordList.push(new StackWord(clone, j + 1));
+            }
+        }
+        stack.push(new StackWord())
+        let state = new State(stack, wordList, new Array<StackRelation>())
+        while (wordList.length > 0 || stack.length > 1) {
+            let firstRelation
+            let first
+            if (wordList.length != 0) {
+                first = wordList[0].getWord()
+                firstRelation = wordMap.get(wordList[0].getToWord()).getRelation()
+            } else {
+                first = null
+                firstRelation = null
+            }
+            let top = stack[stack.length - 1].getWord()
+            if (top.getName() != "root") {
+                topRelation = wordMap.get(stack[stack.length - 1].getToWord()).getRelation()
+            }
+            if (stack.length > 1) {
+                if (firstRelation != null && firstRelation.to() == top.getId()) {
+                    instanceList.push(instanceGenerator.generate(state, windowSize, "RIGHTARC(" + firstRelation + ")"))
+                    let word = wordList.splice(0, 1)[0]
+                    stack.push(new StackWord(wordMap.get(word.getToWord()), word.getToWord()));
+                } else if (first != null && topRelation != null && topRelation.to() == first.getId()) {
+                    instanceList.push(instanceGenerator.generate(state, windowSize, "LEFTARC(" + topRelation + ")"))
+                    stack.pop()
+                } else if (wordList.length > 0) {
+                    instanceList.push(instanceGenerator.generate(state, windowSize, "SHIFT"))
+                    stack.push(wordList.splice(0, 1)[0])
+                } else {
+                    instanceList.push(instanceGenerator.generate(state, windowSize, "REDUCE"))
+                    stack.pop()
+                }
+            } else {
+                if (wordList.length > 0) {
+                    instanceList.push(instanceGenerator.generate(state, windowSize, "SHIFT"))
+                    stack.push(wordList.splice(0, 1)[0])
+                } else {
+                    break
+                }
+            }
+        }
+        return instanceList
+    }
+
+}

package/source/Parser/TransitionBasedParser/ArcStandardOracle.ts

@@ -0,0 +1,28 @@
+import {Oracle} from "./Oracle";
+import {State} from "./State";
+import {Decision} from "./Decision";
+import {Model} from "nlptoolkit-classification/dist/Model/Model";
+import {SimpleInstanceGenerator} from "./SimpleInstanceGenerator";
+
+export class ArcStandardOracle extends Oracle{
+
+    constructor(model: Model, windowSize: number) {
+        super(model, windowSize)
+    }
+
+    public makeDecision(state: State): Decision {
+        let instanceGenerator = new SimpleInstanceGenerator()
+        let instance = instanceGenerator.generate(state, this.windowSize, "")
+        let best = this.findBestValidStandardClassInfo(this.commandModel.predictProbability(instance), state);
+        let decisionCandidate = this.getDecisionCandidate(best)
+        if (decisionCandidate.getCommand() == Command.SHIFT) {
+            return new Decision(Command.SHIFT, null, 0.0)
+        }
+        return new Decision(decisionCandidate.getCommand(), decisionCandidate.getUniversalDependencyType(), 0.0)
+    }
+
+    protected scoreDecisions(state: State, transitionSystem: TransitionSystem): Array<Decision> {
+        return null
+    }
+
+}

package/source/Parser/TransitionBasedParser/ArcStandardTransitionParser.ts

@@ -0,0 +1,123 @@
+import {TransitionParser} from "./TransitionParser";
+import {
+    UniversalDependencyTreeBankSentence
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankSentence";
+import {Oracle} from "./Oracle";
+import {Instance} from "nlptoolkit-classification/dist/Instance/Instance";
+import {StackWord} from "./StackWord";
+import {SimpleInstanceGenerator} from "./SimpleInstanceGenerator";
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+import {State} from "./State";
+import {StackRelation} from "./StackRelation";
+
+export class ArcStandardTransitionParser extends TransitionParser{
+
+    constructor() {
+        super()
+    }
+
+    /**
+     * Checks if there are more relations with a specified ID in the list of words.
+     * @param wordList The list of words to check.
+     * @param id The ID to check for.
+     * @return True if no more relations with the specified ID are found; false otherwise.
+     */
+    private checkForMoreRelation(wordList: Array<StackWord>, id: number){
+        for (let word of wordList) {
+            if (word.getWord().getRelation().to() == id) {
+                return false;
+            }
+        }
+        return true
+    }
+
+    /**
+     * Performs dependency parsing on the given sentence using the provided oracle.
+     * @param universalDependencyTreeBankSentence The sentence to be parsed.
+     * @param oracle The oracle used to make parsing decisions.
+     * @return The parsed sentence with dependency relations established.
+     */
+    dependencyParse(universalDependencyTreeBankSentence: UniversalDependencyTreeBankSentence, oracle: Oracle): UniversalDependencyTreeBankSentence {
+        let sentence = this.createResultSentence(universalDependencyTreeBankSentence)
+        let state = this.initialState(sentence)
+        while (state.wordListSize() > 0 || state.stackSize() > 1) {
+            let decision = oracle.makeDecision(state)
+            switch (decision.getCommand()) {
+                case Command.SHIFT:
+                    state.applyShift()
+                    break
+                case Command.LEFTARC:
+                    state.applyLeftArc(decision.getUniversalDependencyType())
+                    break
+                case Command.RIGHTARC:
+                    state.applyRightArc(decision.getUniversalDependencyType())
+                    break
+                default:
+                    break
+            }
+        }
+        return sentence;
+    }
+
+    /**
+     * Simulates the parsing process for a given sentence using the Arc Standard parsing algorithm.
+     * @param sentence The sentence to be parsed.
+     * @param windowSize The size of the window used for feature generation.
+     * @return An ArrayList of {@link Instance} objects representing the parsed actions.
+     */
+    simulateParse(sentence: UniversalDependencyTreeBankSentence, windowSize: number): Array<Instance> {
+        let instanceGenerator = new SimpleInstanceGenerator()
+        let instanceList = new Array<Instance>()
+        let wordList = new Array<StackWord>()
+        let stack = new Array<StackWord>()
+        for (let j = 0; j < sentence.wordCount(); j++) {
+            let word = sentence.getWord(j)
+            if (word instanceof UniversalDependencyTreeBankWord){
+                wordList.push(new StackWord(word, j + 1))
+            }
+        }
+        stack.push(new StackWord());
+        let state = new State(stack, wordList, new Array<StackRelation>())
+        if (wordList.length > 0) {
+            instanceList.push(instanceGenerator.generate(state, windowSize, "SHIFT"));
+            stack.push(wordList.splice(0, 1)[0])
+            if (wordList.length > 1) {
+                instanceList.push(instanceGenerator.generate(state, windowSize, "SHIFT"))
+                stack.push(wordList.splice(0, 1)[0])
+            }
+            while (wordList.length > 0 || stack.length > 1) {
+                let top = stack[stack.length - 1].getWord()
+                let topRelation = top.getRelation()
+                if (stack.length > 1) {
+                    let beforeTop = stack[stack.length - 2].getWord();
+                    let beforeTopRelation = beforeTop.getRelation()
+                    if (beforeTop.getId() == topRelation.to() && this.checkForMoreRelation(wordList, top.getId())) {
+                        instanceList.push(instanceGenerator.generate(state, windowSize, "RIGHTARC(" + topRelation + ")"))
+                        stack.pop();
+                    } else if (top.getId() == beforeTopRelation.to()) {
+                        instanceList.push(instanceGenerator.generate(state, windowSize, "LEFTARC(" + beforeTopRelation + ")"))
+                        stack.splice(stack.length - 2, 1)
+                    } else {
+                        if (wordList.length > 0) {
+                            instanceList.push(instanceGenerator.generate(state, windowSize, "SHIFT"))
+                            stack.push(wordList.splice(0, 1)[0])
+                        } else {
+                            break
+                        }
+                    }
+                } else {
+                    if (wordList.length > 0) {
+                        instanceList.push(instanceGenerator.generate(state, windowSize, "SHIFT"))
+                        stack.push(wordList.splice(0, 1)[0])
+                    } else {
+                        break
+                    }
+                }
+            }
+        }
+        return instanceList
+    }
+
+}

package/source/Parser/TransitionBasedParser/Candidate.ts

@@ -0,0 +1,20 @@
+import {UniversalDependencyType} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyType";
+
+export class Candidate {
+    private readonly command: Command;
+    private readonly universalDependencyType: UniversalDependencyType
+
+    constructor(command: Command, universalDependencyType: UniversalDependencyType) {
+        this.command = command
+        this.universalDependencyType = universalDependencyType
+    }
+
+    getCommand(): Command{
+        return this.command
+    }
+
+    getUniversalDependencyType(): UniversalDependencyType{
+        return this.universalDependencyType
+    }
+
+}

package/source/Parser/TransitionBasedParser/Command.ts

@@ -0,0 +1,3 @@
+enum Command {
+    RIGHTARC, LEFTARC, SHIFT, REDUCE
+}

package/source/Parser/TransitionBasedParser/Decision.ts

@@ -0,0 +1,16 @@
+import {UniversalDependencyType} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyType";
+import {Candidate} from "./Candidate";
+
+export class Decision extends Candidate{
+
+    private readonly point: number
+
+    constructor(command: Command, universalDependencyType: UniversalDependencyType, point: number) {
+        super(command, universalDependencyType);
+        this.point = point
+    }
+
+    getPoint(): number{
+        return this.point
+    }
+}

package/source/Parser/TransitionBasedParser/InstanceGenerator.ts

@@ -0,0 +1,85 @@
+import {State} from "./State";
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+import {Attribute} from "nlptoolkit-classification/dist/Attribute/Attribute";
+import {
+    UniversalDependencyTreeBankFeatures
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankFeatures";
+import {DiscreteIndexedAttribute} from "nlptoolkit-classification/dist/Attribute/DiscreteIndexedAttribute";
+import {Instance} from "nlptoolkit-classification/dist/Instance/Instance";
+
+export abstract class InstanceGenerator {
+
+    /**
+     * Abstract method for generating an instance based on the current state, window size, and command.
+     * @param state The current state of the parser.
+     * @param windowSize The size of the window used for feature extraction.
+     * @param command The command to be used for generating the instance.
+     * @return The generated {@link Instance} object.
+     */
+    abstract generate(state: State, windowSize: number, command: string): Instance
+
+    /**
+     * Adds an attribute for a specific feature type of a given word to the list of attributes.
+     * @param word The word whose feature value is used to create the attribute.
+     * @param attributes The list of attributes to which the new attribute will be added.
+     * @param featureType The type of the feature to be extracted from the word.
+     */
+    private addAttributeForFeatureType(word: UniversalDependencyTreeBankWord,
+                                       attributes: Array<Attribute>,
+                                       featureType: string){
+        let feature = word.getFeatureValue(featureType)
+        let numberOfValues = UniversalDependencyTreeBankFeatures.numberOfValues("tr", featureType) + 1
+        if (feature != undefined){
+            attributes.push(new DiscreteIndexedAttribute(feature, UniversalDependencyTreeBankFeatures.featureValueIndex("tr", featureType, feature) + 1, numberOfValues))
+        } else {
+            attributes.push(new DiscreteIndexedAttribute("null", 0, numberOfValues))
+        }
+    }
+
+    /**
+     * Adds a set of default (empty) attributes to the list of attributes. These attributes represent
+     * various feature types with default "null" values.
+     * @param attributes The list of attributes to which the default attributes will be added.
+     */
+    protected addEmptyAttributes(attributes: Array<Attribute>){
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "PronType") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "NumType") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Number") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Case") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Definite") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Degree") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "VerbForm") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Mood") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Tense") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Aspect") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Voice") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Evident") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Polarity") + 1))
+        attributes.push(new DiscreteIndexedAttribute("null", 0, UniversalDependencyTreeBankFeatures.numberOfValues("tr", "Person") + 1))
+    }
+
+    /**
+     * Adds attributes for various feature types of a given word to the list of attributes.
+     * @param word The word whose feature values are used to create the attributes.
+     * @param attributes The list of attributes to which the new attributes will be added.
+     */
+    protected addFeatureAttributes(word: UniversalDependencyTreeBankWord,
+                                   attributes: Array<Attribute>){
+        this.addAttributeForFeatureType(word, attributes, "PronType")
+        this.addAttributeForFeatureType(word, attributes, "NumType")
+        this.addAttributeForFeatureType(word, attributes, "Number")
+        this.addAttributeForFeatureType(word, attributes, "Case")
+        this.addAttributeForFeatureType(word, attributes, "Definite")
+        this.addAttributeForFeatureType(word, attributes, "Degree")
+        this.addAttributeForFeatureType(word, attributes, "VerbForm")
+        this.addAttributeForFeatureType(word, attributes, "Mood")
+        this.addAttributeForFeatureType(word, attributes, "Tense")
+        this.addAttributeForFeatureType(word, attributes, "Aspect")
+        this.addAttributeForFeatureType(word, attributes, "Voice")
+        this.addAttributeForFeatureType(word, attributes, "Evident")
+        this.addAttributeForFeatureType(word, attributes, "Polarity")
+        this.addAttributeForFeatureType(word, attributes, "Person")
+    }
+}