CluProcessor

Instance Constructors

new CluProcessor(config: Config = ConfigFactory.load("cluprocessor"), optionalNER: Option[LexiconNER] = None, seasonPathOpt: Option[String] = None)
new CluProcessor(config: Config, optionalNER: Option[LexiconNER], numericEntityRecognizerOpt: Option[NumericEntityRecognizer], internStringsOpt: Option[Boolean], localTokenizerOpt: Option[Tokenizer], lemmatizerOpt: Option[Lemmatizer], mtlPosChunkSrlpOpt: Option[Metal], mtlNerOpt: Option[Metal], mtlSrlaOpt: Option[Metal], mtlDepsHeadOpt: Option[Metal], mtlDepsLabelOpt: Option[Metal])

Attributes
protected

Type Members

class PredicateAttachment extends IntermediateDocumentAttachment

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def annotate(doc: Document): Document

Annotate the given document, returning an annotated document.
Annotate the given document, returning an annotated document. The default implementation is an NLP pipeline of side-effecting calls.

Definition Classes
CluProcessor → Processor
def annotate(text: String, keepText: Boolean = false): Document

Annotate the given text string, specify whether to retain the text in the resultant Document.
Annotate the given text string, specify whether to retain the text in the resultant Document.

Definition Classes
CluProcessor → Processor
def annotateFromSentences(sentences: Iterable[String], keepText: Boolean = false): Document

Annotate the given sentences, specify whether to retain the text in the resultant Document.
Annotate the given sentences, specify whether to retain the text in the resultant Document.

Definition Classes
Processor
def annotateFromTokens(sentences: Iterable[Iterable[String]], keepText: Boolean = false): Document

Annotate the given tokens, specify whether to retain the text in the resultant Document.
Annotate the given tokens, specify whether to retain the text in the resultant Document.

Definition Classes
Processor
final def asInstanceOf[T0]: T0

Definition Classes
Any
def basicSanityCheck(doc: Document): Unit
def cheapLemmatize(doc: Document): Unit

Generates cheap lemmas with the word in lower case, for languages where a lemmatizer is not available
def chunking(doc: Document): Unit

Shallow parsing; modifies the document in place
Shallow parsing; modifies the document in place

Definition Classes
CluProcessor → Processor
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def combineDocuments(documents: IndexedSeq[Document], combinedTextOpt: Option[String]): Document

Attributes
protected
Definition Classes
Processor
val config: Config
def contains(argPath: String): Boolean

Definition Classes
Configured
def copy(configOpt: Option[Config] = None, optionalNEROpt: Option[Option[LexiconNER]] = None, numericEntityRecognizerOptOpt: Option[Option[NumericEntityRecognizer]] = None, internStringsOptOpt: Option[Option[Boolean]] = None, localTokenizerOptOpt: Option[Option[Tokenizer]] = None, lemmatizerOptOpt: Option[Option[Lemmatizer]] = None, mtlPosChunkSrlpOptOpt: Option[Option[Metal]] = None, mtlNerOptOpt: Option[Option[Metal]] = None, mtlSrlaOptOpt: Option[Option[Metal]] = None, mtlDepsHeadOptOpt: Option[Option[Metal]] = None, mtlDepsLabelOptOpt: Option[Option[Metal]] = None): CluProcessor
def discourse(doc: Document): Unit

Discourse parsing; modifies the document in place
Discourse parsing; modifies the document in place

Definition Classes
CluProcessor → Processor
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def getArgBoolean(argPath: String, defaultValue: Option[Boolean]): Boolean

Definition Classes
Configured
def getArgFloat(argPath: String, defaultValue: Option[Float]): Float

Definition Classes
Configured
def getArgInt(argPath: String, defaultValue: Option[Int]): Int

Definition Classes
Configured
def getArgString(argPath: String, defaultValue: Option[String]): String

Definition Classes
Configured
def getArgStrings(argPath: String, defaultValue: Option[Seq[String]]): Seq[String]

Definition Classes
Configured
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getConf: Config

Definition Classes
CluProcessor → Configured
def getEmbeddings(doc: Document): ConstEmbeddingParameters
def getPredicateIndexes(preds: IndexedSeq[String]): IndexedSeq[Int]

Gets the index of all predicates in this sentence
def hashCode(): Int

Definition Classes
AnyRef → Any
val internStrings: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val isPreparedToAnnotate: Boolean

Attributes
protected
val lazyLemmatizer: Lazy[Lemmatizer]

Attributes
protected
val lazyMtlDepsHead: Lazy[Metal]

Attributes
protected
val lazyMtlDepsLabel: Lazy[Metal]

Attributes
protected
val lazyMtlNer: Lazy[Metal]

Attributes
protected
val lazyMtlPosChunkSrlp: Lazy[Metal]

Attributes
protected
val lazyMtlSrla: Lazy[Metal]

Attributes
protected
val lazyNumericEntityRecognizer: Lazy[NumericEntityRecognizer]

Attributes
protected
val lazyTokenizer: Lazy[Tokenizer]

Attributes
protected
def lemmatize(doc: Document): Unit

Lematization; modifies the document in place
Lematization; modifies the document in place

Definition Classes
CluProcessor → Processor
def lemmatizer: Lemmatizer
def mkCombinedDocument(texts: IndexedSeq[String], trailers: IndexedSeq[String], keepText: Boolean = false): Document

Definition Classes
Processor
def mkConstEmbeddings(doc: Document): Unit
def mkDocument(text: String, keepText: Boolean = false): Document

Constructs a document of tokens from free text; includes sentence splitting and tokenization
Constructs a document of tokens from free text; includes sentence splitting and tokenization

Definition Classes
CluProcessor → Processor
def mkDocumentFromSentences(sentences: Iterable[String], keepText: Boolean = false, charactersBetweenSentences: Int = 1): Document

Constructs a document of tokens from an array of untokenized sentences
Constructs a document of tokens from an array of untokenized sentences

Definition Classes
CluProcessor → Processor
def mkDocumentFromTokens(sentences: Iterable[Iterable[String]], keepText: Boolean = false, charactersBetweenSentences: Int = 1, charactersBetweenTokens: Int = 1): Document

Constructs a document of tokens from an array of tokenized sentences
Constructs a document of tokens from an array of tokenized sentences

Definition Classes
CluProcessor → Processor
lazy val mtlCase: Metal
def mtlDepsHead: Metal
def mtlDepsLabel: Metal
def mtlNer: Metal
def mtlPosChunkSrlp: Metal
def mtlSrla: Metal
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nerSentence(words: Array[String], lemmas: Option[Array[String]], tags: Array[String], startCharOffsets: Array[Int], endCharOffsets: Array[Int], docDateOpt: Option[String], embeddings: ConstEmbeddingParameters): (IndexedSeq[String], Option[IndexedSeq[String]])

Produces NE labels for one sentence
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numericEntityRecognizer: NumericEntityRecognizer
val optionalNER: Option[LexiconNER]
def parse(doc: Document): Unit

Syntactic parsing; modifies the document in place
Syntactic parsing; modifies the document in place

Definition Classes
CluProcessor → Processor
def parseSentenceWithEisner(words: IndexedSeq[String], posTags: IndexedSeq[String], nerLabels: IndexedSeq[String], embeddings: ConstEmbeddingParameters): Array[(Int, String)]

Dependency parsing with the Eisner algorithm
def parserPostProcessing(sentence: Sentence, headsWithLabels: Array[(Int, String)]): Unit

Deterministic corrections for dependency parsing
def recognizeNamedEntities(doc: Document): Unit

NER; modifies the document in place
NER; modifies the document in place

Definition Classes
CluProcessor → Processor
def relationExtraction(doc: Document): Unit

Relation extraction; modifies the document in place.
Relation extraction; modifies the document in place.

Definition Classes
CluProcessor → Processor
def removeNumericLabels(allLabels: Array[String]): Array[String]
def resolveCoreference(doc: Document): Unit

Coreference resolution; modifies the document in place
Coreference resolution; modifies the document in place

Definition Classes
CluProcessor → Processor
def restoreCase(doc: Document): Unit

Restores the correct case for all words in a given document
def srl(doc: Document): Unit

Semantic role labeling
Semantic role labeling

Definition Classes
CluProcessor → Processor
def srlSentence(words: IndexedSeq[String], posTags: IndexedSeq[String], nerLabels: IndexedSeq[String], predicateIndexes: IndexedSeq[Int], embeddings: ConstEmbeddingParameters): DirectedGraph[String]

Produces semantic role frames for one sentence
def srlSentence(sent: Sentence, predicateIndexes: IndexedSeq[Int], embeddings: ConstEmbeddingParameters): DirectedGraph[String]

Dependency parsing - OLD greedy algorithm
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tagPartsOfSpeech(doc: Document): Unit

Part of speech tagging + chunking + SRL (predicates), jointly
Part of speech tagging + chunking + SRL (predicates), jointly

Definition Classes
CluProcessor → Processor
def tagSentence(words: IndexedSeq[String], embeddings: ConstEmbeddingParameters): (IndexedSeq[String], IndexedSeq[String], IndexedSeq[String])

Produces POS tags, chunks, and semantic role predicates for one sentence
def toString(): String

Definition Classes
AnyRef → Any
def tokenizer: Tokenizer
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object CluProcessor | package clu

class CluProcessor extends Processor with Configured

Instance Constructors

new CluProcessor(config: Config = ConfigFactory.load("cluprocessor"), optionalNER: Option[LexiconNER] = None, seasonPathOpt: Option[String] = None)

Type Members

class PredicateAttachment extends IntermediateDocumentAttachment

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def annotate(doc: Document): Document

def annotate(text: String, keepText: Boolean = false): Document

def annotateFromSentences(sentences: Iterable[String], keepText: Boolean = false): Document

def annotateFromTokens(sentences: Iterable[Iterable[String]], keepText: Boolean = false): Document

final def asInstanceOf[T0]: T0

def basicSanityCheck(doc: Document): Unit

def cheapLemmatize(doc: Document): Unit

def chunking(doc: Document): Unit

def clone(): AnyRef

def combineDocuments(documents: IndexedSeq[Document], combinedTextOpt: Option[String]): Document

val config: Config

def contains(argPath: String): Boolean

def discourse(doc: Document): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getArgBoolean(argPath: String, defaultValue: Option[Boolean]): Boolean

def getArgFloat(argPath: String, defaultValue: Option[Float]): Float

def getArgInt(argPath: String, defaultValue: Option[Int]): Int

def getArgString(argPath: String, defaultValue: Option[String]): String

def getArgStrings(argPath: String, defaultValue: Option[Seq[String]]): Seq[String]

final def getClass(): Class[_]

def getConf: Config

def getEmbeddings(doc: Document): ConstEmbeddingParameters

def getPredicateIndexes(preds: IndexedSeq[String]): IndexedSeq[Int]

def hashCode(): Int

val internStrings: Boolean

final def isInstanceOf[T0]: Boolean

lazy val isPreparedToAnnotate: Boolean

val lazyLemmatizer: Lazy[Lemmatizer]

val lazyMtlDepsHead: Lazy[Metal]

val lazyMtlDepsLabel: Lazy[Metal]

val lazyMtlNer: Lazy[Metal]

val lazyMtlPosChunkSrlp: Lazy[Metal]

val lazyMtlSrla: Lazy[Metal]

val lazyNumericEntityRecognizer: Lazy[NumericEntityRecognizer]

val lazyTokenizer: Lazy[Tokenizer]

def lemmatize(doc: Document): Unit

def lemmatizer: Lemmatizer

def mkCombinedDocument(texts: IndexedSeq[String], trailers: IndexedSeq[String], keepText: Boolean = false): Document

def mkConstEmbeddings(doc: Document): Unit

def mkDocument(text: String, keepText: Boolean = false): Document

def mkDocumentFromSentences(sentences: Iterable[String], keepText: Boolean = false, charactersBetweenSentences: Int = 1): Document

def mkDocumentFromTokens(sentences: Iterable[Iterable[String]], keepText: Boolean = false, charactersBetweenSentences: Int = 1, charactersBetweenTokens: Int = 1): Document

lazy val mtlCase: Metal

def mtlDepsHead: Metal

def mtlDepsLabel: Metal

def mtlNer: Metal

def mtlPosChunkSrlp: Metal

def mtlSrla: Metal

final def ne(arg0: AnyRef): Boolean

def nerSentence(words: Array[String], lemmas: Option[Array[String]], tags: Array[String], startCharOffsets: Array[Int], endCharOffsets: Array[Int], docDateOpt: Option[String], embeddings: ConstEmbeddingParameters): (IndexedSeq[String], Option[IndexedSeq[String]])

final def notify(): Unit

final def notifyAll(): Unit

def numericEntityRecognizer: NumericEntityRecognizer

val optionalNER: Option[LexiconNER]

def parse(doc: Document): Unit

def parseSentenceWithEisner(words: IndexedSeq[String], posTags: IndexedSeq[String], nerLabels: IndexedSeq[String], embeddings: ConstEmbeddingParameters): Array[(Int, String)]

def parserPostProcessing(sentence: Sentence, headsWithLabels: Array[(Int, String)]): Unit

def recognizeNamedEntities(doc: Document): Unit

def relationExtraction(doc: Document): Unit

def removeNumericLabels(allLabels: Array[String]): Array[String]

def resolveCoreference(doc: Document): Unit

def restoreCase(doc: Document): Unit

def srl(doc: Document): Unit

def srlSentence(words: IndexedSeq[String], posTags: IndexedSeq[String], nerLabels: IndexedSeq[String], predicateIndexes: IndexedSeq[Int], embeddings: ConstEmbeddingParameters): DirectedGraph[String]

def srlSentence(sent: Sentence, predicateIndexes: IndexedSeq[Int], embeddings: ConstEmbeddingParameters): DirectedGraph[String]

final def synchronized[T0](arg0: ⇒ T0): T0

def tagPartsOfSpeech(doc: Document): Unit