class AssertionDLModel extends AnnotatorModel[AssertionDLModel] with WriteTensorflowModel with HasStorageRef with HasSimpleAnnotate[AssertionDLModel] with ParamsAndFeaturesWritable with HandleExceptionParams with CheckLicense
This is a main class in AssertionDL family. A Deep Learning based approach is used to extract Assertion Status
from extracted entities and text. AssertionDLModel requires DOCUMENT, CHUNK and WORD_EMBEDDINGS type
annotator inputs, which can be obtained by e.g a
DocumentAssembler,
NerConverter
and WordEmbeddingsModel.
The result is an assertion status annotation for each recognized entity.
Possible values include “present”, “absent”, “hypothetical”, “conditional”, “associated_with_other_person”
etc.
For pretrained models please see the Models Hub for available models.
Example
Define pipeline stages to extract NER chunks first
val data = Seq( "Patient with severe fever and sore throat", "Patient shows no stomach pain", "She was maintained on an epidural and PCA for pain control.").toDF("text") val documentAssembler = new DocumentAssembler().setInputCol("text").setOutputCol("document") val sentenceDetector = new SentenceDetector().setInputCols("document").setOutputCol("sentence") val tokenizer = new Tokenizer().setInputCols("sentence").setOutputCol("token") val embeddings = WordEmbeddingsModel.pretrained("embeddings_clinical", "en", "clinical/models") .setOutputCol("embeddings") val nerModel = MedicalNerModel.pretrained("ner_clinical", "en", "clinical/models") .setInputCols("sentence", "token", "embeddings").setOutputCol("ner") val nerConverter = new NerConverter().setInputCols("sentence", "token", "ner").setOutputCol("ner_chunk")
Then a pretrained AssertionDLModel is used to extract the assertion status
val clinicalAssertion = AssertionDLModel.pretrained("assertion_dl", "en", "clinical/models") .setInputCols("sentence", "ner_chunk", "embeddings") .setOutputCol("assertion") val assertionPipeline = new Pipeline().setStages(Array( documentAssembler, sentenceDetector, tokenizer, embeddings, nerModel, nerConverter, clinicalAssertion )) val assertionModel = assertionPipeline.fit(data)
Show results
val result = assertionModel.transform(data) result.selectExpr("ner_chunk.result", "assertion.result").show(3, truncate=false) +--------------------------------+--------------------------------+ |result |result | +--------------------------------+--------------------------------+ |[severe fever, sore throat] |[present, present] | |[stomach pain] |[absent] | |[an epidural, PCA, pain control]|[present, present, hypothetical]| +--------------------------------+--------------------------------+
- See also
AssertionDLApproach for training a custom AssertionDLModel
AssertionLogRegModel for non deep learning based extraction
- Grouped
- Alphabetic
- By Inheritance
- AssertionDLModel
- CheckLicense
- HandleExceptionParams
- HasSimpleAnnotate
- HasStorageRef
- WriteTensorflowModel
- AnnotatorModel
- CanBeLazy
- RawAnnotator
- HasOutputAnnotationCol
- HasInputAnnotationCols
- HasOutputAnnotatorType
- ParamsAndFeaturesWritable
- HasFeatures
- DefaultParamsWritable
- MLWritable
- Model
- Transformer
- PipelineStage
- Logging
- Params
- Serializable
- Serializable
- Identifiable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
Type Members
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
$[T](param: Param[T]): T
- Attributes
- protected
- Definition Classes
- Params
-
def
$$[T](feature: StructFeature[T]): T
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
$$[K, V](feature: MapFeature[K, V]): Map[K, V]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
$$[T](feature: SetFeature[T]): Set[T]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
$$[T](feature: ArrayFeature[T]): Array[T]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
_transform(dataset: Dataset[_], recursivePipeline: Option[PipelineModel]): DataFrame
- Attributes
- protected
- Definition Classes
- AnnotatorModel
-
def
afterAnnotate(dataset: DataFrame): DataFrame
- Attributes
- protected
- Definition Classes
- AnnotatorModel
-
def
annotate(annotations: Seq[Annotation]): Seq[Annotation]
This is main point of interest.
This is main point of interest. It annotates the input dataset applying properties of the class above This method utilises chunk groups, word piece embeddings and conversion to chunk indexes
- annotations
a sequence of Annotations
- returns
a sequence of projected Annotations
- Definition Classes
- AssertionDLModel → HasSimpleAnnotate
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
val
batchSize: IntParam
Size of every batch
-
def
beforeAnnotate(dataset: Dataset[_]): Dataset[_]
This method validates the dataset before annotation
This method validates the dataset before annotation
- dataset
a collection of inputs to validate
- returns
a Dataset after validation
- Attributes
- protected
- Definition Classes
- AssertionDLModel → AnnotatorModel
- def checkEntityAssertion(entity: String, assertion: String): Boolean
-
final
def
checkSchema(schema: StructType, inputAnnotatorType: String): Boolean
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
-
def
checkValidEnvironment(spark: Option[SparkSession], scopes: Seq[String]): Unit
- Definition Classes
- CheckLicense
-
def
checkValidScope(scope: String): Unit
- Definition Classes
- CheckLicense
-
def
checkValidScopeAndEnvironment(scope: String, spark: Option[SparkSession], checkLp: Boolean): Unit
- Definition Classes
- CheckLicense
-
def
checkValidScopesAndEnvironment(scopes: Seq[String], spark: Option[SparkSession], checkLp: Boolean): Unit
- Definition Classes
- CheckLicense
-
val
classes: StringArrayParam
List of internal copies of classes used to train for Python
-
final
def
clear(param: Param[_]): AssertionDLModel.this.type
- Definition Classes
- Params
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
val
configProtoBytes: IntArrayParam
ConfigProto from tensorflow, serialized into byte array.
ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString Example Python code with TF version 2.3: In [1]: import tensorflow as tf In [2]: config = tf.compat.v1.ConfigProto(allow_soft_placement=True, log_device_placement=True) ...: config.gpu_options.allow_growth = True ...: for b in config.SerializeToString(): ...: print(b) ...: 50 2 32 1 56 1 64 1
-
def
copy(extra: ParamMap): AssertionDLModel
requirement for annotators copies
requirement for annotators copies
- Definition Classes
- AssertionDLModel → RawAnnotator → Model → Transformer → PipelineStage → Params
-
def
copyValues[T <: Params](to: T, extra: ParamMap): T
- Attributes
- protected
- Definition Classes
- Params
-
def
createDatabaseConnection(database: Name): RocksDBConnection
- Definition Classes
- HasStorageRef
-
val
datasetParams: StructFeature[DatasetEncoderParams]
Collection of Parameters, which are used by method annotate()
-
final
def
defaultCopy[T <: Params](extra: ParamMap): T
- Attributes
- protected
- Definition Classes
- Params
-
def
dfAnnotate: UserDefinedFunction
- Definition Classes
- HasSimpleAnnotate
-
val
doExceptionHandling: BooleanParam
If true, exceptions are handled.
If true, exceptions are handled. If exception causing data is passed to the model, a error annotation is emitted which has the exception message. Processing continues with the next one. This comes with a performance penalty.
- Definition Classes
- HandleExceptionParams
-
var
entityAssertionCaseSensitive: BooleanParam
Determines whether entity labels and assertion labels are case sensitive
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
explainParam(param: Param[_]): String
- Definition Classes
- Params
-
def
explainParams(): String
- Definition Classes
- Params
-
def
extraValidate(structType: StructType): Boolean
- Attributes
- protected
- Definition Classes
- RawAnnotator
-
def
extraValidateMsg: String
- Attributes
- protected
- Definition Classes
- RawAnnotator
-
final
def
extractParamMap(): ParamMap
- Definition Classes
- Params
-
final
def
extractParamMap(extra: ParamMap): ParamMap
- Definition Classes
- Params
-
val
features: ArrayBuffer[Feature[_, _, _]]
- Definition Classes
- HasFeatures
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
get[T](feature: StructFeature[T]): Option[T]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
get[K, V](feature: MapFeature[K, V]): Option[Map[K, V]]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
get[T](feature: SetFeature[T]): Option[Set[T]]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
get[T](feature: ArrayFeature[T]): Option[Array[T]]
- Attributes
- protected
- Definition Classes
- HasFeatures
-
final
def
get[T](param: Param[T]): Option[T]
- Definition Classes
- Params
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
getClasses: Array[String]
get the tags used to trained this NerDLModel
-
def
getConfigProtoBytes: Option[Array[Byte]]
ConfigProto from tensorflow, serialized into byte array.
ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString
- def getConfigProtoBytesAsInt: Option[Array[Int]]
- def getDatasetParams: DatasetEncoderParams
-
final
def
getDefault[T](param: Param[T]): Option[T]
- Definition Classes
- Params
-
def
getEntityAssertion: Map[String, Array[String]]
Get the lists of assertion labels allowed for a given entity
-
def
getEntityAssertionCaseSensitive: Boolean
Gets the case sensitivity of entities and assertion labels
-
def
getEntityAssertionStr: String
Get the string representation of the lists of assertion labels allowed for a given entity
-
def
getIncludeConfidence: Boolean
whether to include confidence scores in annotation metadata
-
def
getInputCols: Array[String]
- Definition Classes
- HasInputAnnotationCols
-
def
getLazyAnnotator: Boolean
- Definition Classes
- CanBeLazy
-
final
def
getOrDefault[T](param: Param[T]): T
- Definition Classes
- Params
-
final
def
getOutputCol: String
- Definition Classes
- HasOutputAnnotationCol
-
def
getParam(paramName: String): Param[Any]
- Definition Classes
- Params
-
def
getReplaceLabels: Map[String, String]
Gets the assertion labels to be replaced for the specified new labels.
-
def
getReplaceLabelsStr: String
Gets the string presentation of the assertion labels to be replaced for the specified new labels.
-
def
getScopeWindow: (Int, Int)
Get scope window
-
def
getStorageRef: String
- Definition Classes
- HasStorageRef
-
final
def
hasDefault[T](param: Param[T]): Boolean
- Definition Classes
- Params
-
def
hasParam(paramName: String): Boolean
- Definition Classes
- Params
-
def
hasParent: Boolean
- Definition Classes
- Model
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
val
includeConfidence: BooleanParam
whether to include confidence scores in annotation metadata (Default: false)
-
def
initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- Attributes
- protected
- Definition Classes
- Logging
-
def
initializeLogIfNecessary(isInterpreter: Boolean): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
val
inputAnnotatorTypes: Array[String]
Input annotator types: DOCUMENT, CHUNK, WORD_EMBEDDINGS
Input annotator types: DOCUMENT, CHUNK, WORD_EMBEDDINGS
- Definition Classes
- AssertionDLModel → HasInputAnnotationCols
-
final
val
inputCols: StringArrayParam
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
-
final
def
isDefined(param: Param[_]): Boolean
- Definition Classes
- Params
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
isSet(param: Param[_]): Boolean
- Definition Classes
- Params
-
def
isTraceEnabled(): Boolean
- Attributes
- protected
- Definition Classes
- Logging
-
val
lazyAnnotator: BooleanParam
- Definition Classes
- CanBeLazy
-
def
log: Logger
- Attributes
- protected
- Definition Classes
- Logging
-
def
logDebug(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logDebug(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logError(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logError(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logInfo(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logInfo(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logName: String
- Attributes
- protected
- Definition Classes
- Logging
-
def
logTrace(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logTrace(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logWarning(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logWarning(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
val
maxSentLen: IntParam
Max possible length of a sentence (Default: 256)
-
def
model: TensorflowAssertion
Tensorflow model for the AssertionDLModel.
Tensorflow model for the AssertionDLModel. This is used to generate the predictions.
-
def
msgHelper(schema: StructType): String
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
onWrite(path: String, spark: SparkSession): Unit
- Definition Classes
- AssertionDLModel → ParamsAndFeaturesWritable
-
val
optionalInputAnnotatorTypes: Array[String]
- Definition Classes
- HasInputAnnotationCols
-
val
outputAnnotatorType: AnnotatorType
Output annotator types: ASSERTION
Output annotator types: ASSERTION
- Definition Classes
- AssertionDLModel → HasOutputAnnotatorType
-
final
val
outputCol: Param[String]
- Attributes
- protected
- Definition Classes
- HasOutputAnnotationCol
-
lazy val
params: Array[Param[_]]
- Definition Classes
- Params
-
var
parent: Estimator[AssertionDLModel]
- Definition Classes
- Model
-
def
save(path: String): Unit
- Definition Classes
- MLWritable
- Annotations
- @Since( "1.6.0" ) @throws( ... )
-
val
scopeWindow: IntArrayParam
The scope window of the assertion (whole sentence by default)
-
def
set[T](feature: StructFeature[T], value: T): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
set[K, V](feature: MapFeature[K, V], value: Map[K, V]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
set[T](feature: SetFeature[T], value: Set[T]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
set[T](feature: ArrayFeature[T], value: Array[T]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
final
def
set(paramPair: ParamPair[_]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- Params
-
final
def
set(param: String, value: Any): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- Params
-
final
def
set[T](param: Param[T], value: T): AssertionDLModel.this.type
- Definition Classes
- Params
-
def
setBatchSize(size: Int): AssertionDLModel.this.type
Size of every batch
-
def
setConfigProtoBytes(bytes: Array[Int]): AssertionDLModel
ConfigProto from tensorflow, serialized into byte array.
ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString
-
def
setDatasetParams(params: DatasetEncoderParams): AssertionDLModel
Collection of Parameters, which are used by method annotate()
-
def
setDefault[T](feature: StructFeature[T], value: () ⇒ T): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
setDefault[K, V](feature: MapFeature[K, V], value: () ⇒ Map[K, V]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
setDefault[T](feature: SetFeature[T], value: () ⇒ Set[T]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
def
setDefault[T](feature: ArrayFeature[T], value: () ⇒ Array[T]): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
-
final
def
setDefault(paramPairs: ParamPair[_]*): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- Params
-
final
def
setDefault[T](param: Param[T], value: T): AssertionDLModel.this.type
- Attributes
- protected
- Definition Classes
- Params
-
def
setDoExceptionHandling(value: Boolean): AssertionDLModel.this.type
If true, exceptions are handled.
If true, exceptions are handled. If exception causing data is passed to the model, a error annotation is emitted which has the exception message. Processing continues with the next one. This comes with a performance penalty.
- Definition Classes
- HandleExceptionParams
-
def
setEntityAssertion(assertionEntities: HashMap[String, List[String]]): AssertionDLModel.this.type
Set the lists of assertion labels allowed for a given entity.
Set the lists of assertion labels allowed for a given entity.
- Note
entityAssertion functionality is processed earlier than replaceLabels
-
def
setEntityAssertion(assertionEntities: Map[String, Array[String]]): AssertionDLModel.this.type
Set the lists of assertion labels allowed for a given entity.
Set the lists of assertion labels allowed for a given entity.
- Note
entityAssertion functionality is processed earlier than replaceLabels
-
def
setEntityAssertionCaseSensitive(value: Boolean): AssertionDLModel
Sets the case sensitivity of entities and assertion labels
-
def
setIncludeConfidence(value: Boolean): AssertionDLModel.this.type
whether to include confidence scores in annotation metadata
-
final
def
setInputCols(value: String*): AssertionDLModel.this.type
- Definition Classes
- HasInputAnnotationCols
-
def
setInputCols(value: Array[String]): AssertionDLModel.this.type
- Definition Classes
- HasInputAnnotationCols
-
def
setLazyAnnotator(value: Boolean): AssertionDLModel.this.type
- Definition Classes
- CanBeLazy
-
def
setMaxSentLen(len: Int): AssertionDLModel.this.type
Max possible length of a sentence.
-
final
def
setOutputCol(value: String): AssertionDLModel.this.type
- Definition Classes
- HasOutputAnnotationCol
-
def
setParent(parent: Estimator[AssertionDLModel]): AssertionDLModel
- Definition Classes
- Model
-
def
setReplaceLabels(value: Map[String, String]): AssertionDLModel.this.type
Sets the replaceLabels to be replaced for the specified new labels.
Sets the replaceLabels to be replaced for the specified new labels.
- value
A map containing the replacement labels.
- Note
replaceLabels functionality runs later than entityAssertion
-
def
setReplaceLabels(value: HashMap[String, String]): AssertionDLModel.this.type
Sets the replaceLabels to be replaced for the specified new labels.
Sets the replaceLabels to be replaced for the specified new labels.
- value
A map containing the replacement labels.
- Note
replaceLabels functionality is processed later than entityAssertion
-
def
setScopeWindow(window: (Int, Int)): AssertionDLModel.this.type
Max possible length of a sentence.
-
def
setStorageRef(value: String): AssertionDLModel.this.type
- Definition Classes
- HasStorageRef
- def setTensorflow(spark: SparkSession, tf: TensorflowWrapper): AssertionDLModel
-
val
storageRef: Param[String]
- Definition Classes
- HasStorageRef
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- Identifiable → AnyRef → Any
-
final
def
transform(dataset: Dataset[_]): DataFrame
- Definition Classes
- AnnotatorModel → Transformer
-
def
transform(dataset: Dataset[_], paramMap: ParamMap): DataFrame
- Definition Classes
- Transformer
- Annotations
- @Since( "2.0.0" )
-
def
transform(dataset: Dataset[_], firstParamPair: ParamPair[_], otherParamPairs: ParamPair[_]*): DataFrame
- Definition Classes
- Transformer
- Annotations
- @Since( "2.0.0" ) @varargs()
-
final
def
transformSchema(schema: StructType): StructType
- Definition Classes
- RawAnnotator → PipelineStage
-
def
transformSchema(schema: StructType, logging: Boolean): StructType
- Attributes
- protected
- Definition Classes
- PipelineStage
- Annotations
- @DeveloperApi()
-
val
uid: String
- Definition Classes
- AssertionDLModel → Identifiable
-
def
validate(schema: StructType): Boolean
- Attributes
- protected
- Definition Classes
- RawAnnotator
-
def
validateStorageRef(dataset: Dataset[_], inputCols: Array[String], annotatorType: String): Unit
- Definition Classes
- HasStorageRef
-
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( ... ) @native()
-
def
wrapColumnMetadata(col: Column): Column
- Attributes
- protected
- Definition Classes
- RawAnnotator
-
def
write: MLWriter
- Definition Classes
- ParamsAndFeaturesWritable → DefaultParamsWritable → MLWritable
-
def
writeTensorflowHub(path: String, tfPath: String, spark: SparkSession, suffix: String): Unit
- Definition Classes
- WriteTensorflowModel
-
def
writeTensorflowModel(path: String, spark: SparkSession, tensorflow: TensorflowWrapper, suffix: String, filename: String, configProtoBytes: Option[Array[Byte]]): Unit
- Definition Classes
- WriteTensorflowModel
-
def
writeTensorflowModelV2(path: String, spark: SparkSession, tensorflow: TensorflowWrapper, suffix: String, filename: String, configProtoBytes: Option[Array[Byte]], savedSignatures: Option[Map[String, String]]): Unit
- Definition Classes
- WriteTensorflowModel
Inherited from CheckLicense
Inherited from HandleExceptionParams
Inherited from HasSimpleAnnotate[AssertionDLModel]
Inherited from HasStorageRef
Inherited from WriteTensorflowModel
Inherited from AnnotatorModel[AssertionDLModel]
Inherited from CanBeLazy
Inherited from RawAnnotator[AssertionDLModel]
Inherited from HasOutputAnnotationCol
Inherited from HasInputAnnotationCols
Inherited from HasOutputAnnotatorType
Inherited from ParamsAndFeaturesWritable
Inherited from HasFeatures
Inherited from DefaultParamsWritable
Inherited from MLWritable
Inherited from Model[AssertionDLModel]
Inherited from Transformer
Inherited from PipelineStage
Inherited from Logging
Inherited from Params
Inherited from Serializable
Inherited from Serializable
Inherited from Identifiable
Inherited from AnyRef
Inherited from Any
Parameters
Annotator types
Required input and expected output annotator types