TensorflowForClassification

abstract def findIndexedToken(tokenizedSentences: Seq[TokenizedSentence], sentence: (WordpieceTokenizedSentence, Int), tokenPiece: TokenPiece): Option[IndexedToken]

abstract val sentenceEndTokenId: Int

abstract val sentencePadTokenId: Int

abstract val sentenceStartTokenId: Int

abstract def tag(batch: Seq[Array[Int]]): Seq[Array[Array[Float]]]

abstract def tagSequence(batch: Seq[Array[Int]], activation: String): Array[Array[Float]]

abstract def tokenizeWithAlignment(sentences: Seq[TokenizedSentence], maxSeqLength: Int, caseSensitive: Boolean): Seq[WordpieceTokenizedSentence]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def calculateSigmoid(scores: Array[Float]): Array[Float]

Calcuate sigmoid from returned logits

def calculateSoftmax(scores: Array[Float]): Array[Float]

Calcuate softmax from retruned logits

def clone(): AnyRef

def constructAnnotationForSequenceClassifier(sentence: Sentence, label: String, meta: Array[(String, String)]): Annotation

def constructMetaForSequenceClassifier(tags: Map[String, Int], scores: Array[Float]): Array[(String, String)]

def encode(sentences: Seq[(WordpieceTokenizedSentence, Int)], maxSequenceLength: Int): Seq[Array[Int]]

Encode the input sequence to indexes IDs adding padding where necessary

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def predict(tokenizedSentences: Seq[TokenizedSentence], batchSize: Int, maxSentenceLength: Int, caseSensitive: Boolean, tags: Map[String, Int]): Seq[Annotation]

def predictSequence(tokenizedSentences: Seq[TokenizedSentence], sentences: Seq[Sentence], batchSize: Int, maxSentenceLength: Int, caseSensitive: Boolean, coalesceSentences: Boolean = false, tags: Map[String, Int], activation: String = ActivationFunction.softmax): Seq[Annotation]

def scoresToLabelForSequenceClassifier(tags: Map[String, Int], scores: Array[Float]): String

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

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wordAndSpanLevelAlignmentWithTokenizer(tokenLogits: Array[Array[Float]], tokenizedSentences: Seq[TokenizedSentence], sentence: (WordpieceTokenizedSentence, Int), tags: Map[String, Int]): Seq[Annotation]

Word-level and span-level alignment with Tokenizer https://github.com/google-research/bert#tokenization