edu.stanford.nlp.parser.nndep.Configuration Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of stanford-corenlp Show documentation

Stanford CoreNLP provides a set of natural language analysis tools which can take raw English language text input and give the base forms of words, their parts of speech, whether they are names of companies, people, etc., normalize dates, times, and numeric quantities, mark up the structure of sentences in terms of phrases and word dependencies, and indicate which noun phrases refer to the same entities. It provides the foundational building blocks for higher level text understanding applications.

There is a newer version: 4.5.7

Show newest version


package edu.stanford.nlp.parser.nndep;

import edu.stanford.nlp.ling.CoreAnnotations;
import edu.stanford.nlp.ling.CoreLabel;
import edu.stanford.nlp.util.CoreMap;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

/**
 * Describe the current configuration of a parser (i.e., parser state).
 *
 * This class uses an indexing scheme where an index of zero refers to
 * the ROOT node and actual word indices begin at one.
 *
 * @author Danqi Chen
 */
public class Configuration {

  final List stack;
  final List buffer;

  final DependencyTree tree;
  final CoreMap sentence;

  public Configuration(Configuration config) {
    stack = new ArrayList<>(config.stack);
    buffer = new ArrayList<>(config.buffer);
    tree = new DependencyTree(config.tree);
    sentence = new CoreLabel(config.sentence);
  }

  public Configuration(CoreMap sentence) {
    this.stack = new ArrayList<>();
    this.buffer = new ArrayList<>();
    this.tree = new DependencyTree();
    this.sentence = sentence;
  }

  public boolean shift() {
    int k = getBuffer(0);
    if (k == Config.NONEXIST)
      return false;
    buffer.remove(0);
    stack.add(k);
    return true;
  }

  public boolean removeSecondTopStack() {
    int nStack = getStackSize();
    if (nStack < 2)
      return false;
    stack.remove(nStack - 2);
    return true;
  }

  public boolean removeTopStack() {
    int nStack = getStackSize();
    if (nStack < 1)
      return false;
    stack.remove(nStack - 1);
    return true;
  }

  public int getStackSize() {
    return stack.size();
  }

  public int getBufferSize() {
    return buffer.size();
  }

  public int getSentenceSize() {
    return getCoreLabels().size();
  }
  /**
   * @param k Word index (zero = root node; actual word indexing
   *          begins at 1)
   */
  public int getHead(int k) {
    return tree.getHead(k);
  }

  /**
   * @param k Word index (zero = root node; actual word indexing
   *          begins at 1)
   */
  public String getLabel(int k) {
    return tree.getLabel(k);
  }

  /**
   * Get the sentence index of the kth word on the stack.
   *
   * @return Sentence index or {@link Config#NONEXIST} if stack doesn't
   *         have an element at this index
   */
  public int getStack(int k) {
    int nStack = getStackSize();
    return (k >= 0 && k < nStack) ? stack.get(nStack - 1 - k) : Config.NONEXIST;
  }

  /**
   * Get the sentence index of the kth word on the buffer.
   *
   * @return Sentence index or {@link Config#NONEXIST} if stack doesn't
   *         have an element at this index
   */
  public int getBuffer(int k) {
    return (k >= 0 && k < getBufferSize()) ? buffer.get(k) : Config.NONEXIST;
  }

  public List getCoreLabels() {
    return sentence.get(CoreAnnotations.TokensAnnotation.class);
  }

  /**
   * @param k Word index (zero = root node; actual word indexing
   *          begins at 1)
   */
  public String getWord(int k) {
    if (k == 0) return Config.ROOT;
    else k--;

    List lbls = getCoreLabels();
    return k < 0 || k >= lbls.size() ? Config.NULL : lbls.get(k).word();
  }

  /**
   * @param k Word index (zero = root node; actual word indexing
   *          begins at 1)
   */
  public String getPOS(int k) {
    if (k == 0) return Config.ROOT;
    else k--;

    List lbls = getCoreLabels();
    return k < 0 || k >= lbls.size() ? Config.NULL : lbls.get(k).tag();
  }

  /**
   * @param h Word index of governor (zero = root node; actual word
   *          indexing begins at 1)
   * @param t Word index of dependent (zero = root node; actual word
   *          indexing begins at 1)
   * @param l Arc label
   */
  public void addArc(int h, int t, String l) {
    tree.set(t, h, l);
  }

  public int getLeftChild(int k, int cnt) {
    if (k < 0 || k > tree.n)
      return Config.NONEXIST;

    int c = 0;
    for (int i = 1; i < k; ++i)
      if (tree.getHead(i) == k)
        if ((++c) == cnt)
          return i;
    return Config.NONEXIST;
  }

  public int getLeftChild(int k) {
    return getLeftChild(k, 1);
  }

  public int getRightChild(int k, int cnt) {
    if (k < 0 || k > tree.n)
      return Config.NONEXIST;

    int c = 0;
    for (int i = tree.n; i > k; --i)
      if (tree.getHead(i) == k)
        if ((++c) == cnt)
          return i;
    return Config.NONEXIST;
  }

  public int getRightChild(int k) {
    return getRightChild(k, 1);
  }


  public boolean hasOtherChild(int k, DependencyTree goldTree) {
    for (int i = 1; i <= tree.n; ++i)
      if (goldTree.getHead(i) == k && tree.getHead(i) != k) return true;
    return false;
  }

  public int getLeftValency(int k) {
    if (k < 0 || k > tree.n)
      return Config.NONEXIST;
    int cnt = 0;
    for (int i = 1; i < k; ++i)
      if (tree.getHead(i) == k)
        ++cnt;
    return cnt;
  }

  public int getRightValency(int k) {
    if (k < 0 || k > tree.n)
      return Config.NONEXIST;
    int cnt = 0;
    for (int i = k + 1; i <= tree.n; ++i)
      if (tree.getHead(i) == k)
        ++cnt;
    return cnt;
  }

  public String getLeftLabelSet(int k) {
    if (k < 0 || k > tree.n)
      return Config.NULL;

    HashSet labelSet = new HashSet<>();
    for (int i = 1; i < k; ++i)
      if (tree.getHead(i) == k)
        labelSet.add(tree.getLabel(i));

    List ls = new ArrayList<>(labelSet);
    Collections.sort(ls);
    String s = "";
    for (String l : ls) s = s + "/" + l;
    return s;
  }

  public String getRightLabelSet(int k) {
    if (k < 0 || k > tree.n)
      return Config.NULL;

    HashSet labelSet = new HashSet<>();
    for (int i = k + 1; i <= tree.n; ++i)
      if (tree.getHead(i) == k)
        labelSet.add(tree.getLabel(i));

    List ls = new ArrayList<>(labelSet);
    Collections.sort(ls);
    String s = "";
    for (String l : ls) s = s + "/" + l;
    return s;
  }

  //returns a string that concatenates all elements on the stack and buffer, and head / label.
  public String getStr() {
    String s = "[S]";
    for (int i = 0; i < getStackSize(); ++i) {
      if (i > 0) s = s + ",";
      s = s + stack.get(i);
    }
    s = s + "[B]";
    for (int i = 0; i < getBufferSize(); ++i) {
      if (i > 0) s = s + ",";
      s = s + buffer.get(i);
    }
    s = s + "[H]";
    for (int i = 1; i <= tree.n; ++i) {
      if (i > 1) s = s + ",";
      s = s + getHead(i) + "(" + getLabel(i) + ")";
    }
    return s;
  }
}