com.johnsnowlabs.legal.graph.relation_extraction

RelationExtractionDLModel

Companion object RelationExtractionDLModel

class RelationExtractionDLModel extends nlp.annotators.re.RelationExtractionDLModel

Extracts and classifies instances of relations between named entities. In contrast with RelationExtractionModel, RelationExtractionDLModel is based on BERT. For pretrained models please see the Models Hub for available models.

Example

Relation Extraction between body parts

This is a continuation of the RENerChunksFilter example. See that class on how to extract the relation chunks. Define the extraction model

val re_ner_chunk_filter = new RENerChunksFilter()
 .setInputCols("ner_chunks", "dependencies")
 .setOutputCol("re_ner_chunks")
 .setMaxSyntacticDistance(4)
 .setRelationPairs(Array("internal_organ_or_component-direction"))

val re_model = RelationExtractionDLModel.pretrained("redl_bodypart_direction_biobert", "en", "clinical/models")
  .setPredictionThreshold(0.5f)
  .setInputCols("re_ner_chunks", "sentences")
  .setOutputCol("relations")

val trained_pipeline = new Pipeline().setStages(Array(
  documenter,
  sentencer,
  tokenizer,
  words_embedder,
  pos_tagger,
  clinical_ner_tagger,
  ner_chunker,
  dependency_parser,
  re_ner_chunk_filter,
  re_model
))

val data = Seq("MRI demonstrated infarction in the upper brain stem , left cerebellum and  right basil ganglia").toDF("text")
val result = trained_pipeline.fit(data).transform(data)

Show results

result.selectExpr("explode(relations) as relations")
 .select(
   "relations.metadata.chunk1",
   "relations.metadata.entity1",
   "relations.metadata.chunk2",
   "relations.metadata.entity2",
   "relations.result"
 )
 .where("result != 0")
 .show(truncate=false)
+------+---------+-------------+---------------------------+------+
|chunk1|entity1  |chunk2       |entity2                    |result|
+------+---------+-------------+---------------------------+------+
|upper |Direction|brain stem   |Internal_organ_or_component|1     |
|left  |Direction|cerebellum   |Internal_organ_or_component|1     |
|right |Direction|basil ganglia|Internal_organ_or_component|1     |
+------+---------+-------------+---------------------------+------+

See also: RelationExtractionModel for ML based extraction
RENerChunksFilter on how to create inputs

Linear Supertypes

nlp.annotators.re.RelationExtractionDLModel, CheckLicense, HasSafeAnnotate[nlp.annotators.re.RelationExtractionDLModel], HandleExceptionParams, HasEngine, RelationEncoding, HasSimpleAnnotate[nlp.annotators.re.RelationExtractionDLModel], HasCaseSensitiveProperties, HasStorageRef, WriteTensorflowModel, AnnotatorModel[nlp.annotators.re.RelationExtractionDLModel], CanBeLazy, RawAnnotator[nlp.annotators.re.RelationExtractionDLModel], HasOutputAnnotationCol, HasInputAnnotationCols, HasOutputAnnotatorType, ParamsAndFeaturesWritable, HasFeatures, DefaultParamsWritable, MLWritable, Model[nlp.annotators.re.RelationExtractionDLModel], Transformer, PipelineStage, Logging, Params, Serializable, Serializable, Identifiable, AnyRef, Any

Ordering

Grouped
Alphabetic
By Inheritance

Inherited

RelationExtractionDLModel
RelationExtractionDLModel
CheckLicense
HasSafeAnnotate
HandleExceptionParams
HasEngine
RelationEncoding
HasSimpleAnnotate
HasCaseSensitiveProperties
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

Visibility

Public
All

Instance Constructors

new RelationExtractionDLModel()
new RelationExtractionDLModel(uid: String)
uid
a unique identifier for the instantiated AnnotatorModel

Type Members

type AnnotationContent = Seq[Row]

Attributes
protected
Definition Classes
AnnotatorModel
type AnnotatorType = String

Definition Classes
HasOutputAnnotatorType

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]
takes a document and annotations and produces new annotations of this annotator's annotation type
takes a document and annotations and produces new annotations of this annotator's annotation type
annotations
Annotations that correspond to inputAnnotationCols generated by previous annotators if any
returns
any number of annotations processed for every input annotation. Not necessary one to one relationship

Definition Classes
RelationExtractionDLModel → RelationExtractionDLModel → HasSimpleAnnotate
final def asInstanceOf[T0]: T0

Definition Classes
Any
var batchSize: IntParam
Size of the batches to process.
Size of the batches to process.

Definition Classes
RelationExtractionDLModel
def beforeAnnotate(dataset: Dataset[_]): Dataset[_]

Definition Classes
RelationExtractionDLModel → RelationExtractionDLModel → AnnotatorModel
var bertREConfig: BertREConfig

Definition Classes
RelationExtractionDLModel
val caseSensitive: BooleanParam

Definition Classes
HasCaseSensitiveProperties
def categorizeRelations(relations: Seq[DLRelationInstance]): Seq[(Int, Int, Float)]

Attributes
protected
Definition Classes
RelationExtractionDLModel
var categoryNames: StringArrayParam
List of relation names.
List of relation names.

Definition Classes
RelationExtractionDLModel
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
Categorization classes
Categorization classes

Definition Classes
RelationExtractionDLModel
final def clear(param: Param[_]): RelationExtractionDLModel.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()

Definition Classes
RelationExtractionDLModel
def copy(extra: ParamMap): nlp.annotators.re.RelationExtractionDLModel

Definition Classes
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
var customLabels: MapFeature[String, String]
Custom relation labels
Custom relation labels

Definition Classes
RelationExtractionDLModel
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
def encodeRelations(nerChunkAnnotations: Seq[Annotation], sentenceAnnotations: Seq[Annotation]): Seq[DLRelationInstance]

Definition Classes
RelationEncoding
val engine: Param[String]

Definition Classes
HasEngine
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
def getBatchSize: Int
Number of relations to process in a batch
Number of relations to process in a batch

Definition Classes
RelationExtractionDLModel
def getCaseSensitive: Boolean

Definition Classes
HasCaseSensitiveProperties
def getCategories(): Array[String]
Get all categories
Get all categories

Definition Classes
RelationExtractionDLModel
def getCategoryName(id: Int): String
List of relation names
List of relation names

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

Definition Classes
AnyRef → Any
Annotations
@native()
def getClasses: Array[String]
Proxy to getCategories
Proxy to getCategories

Definition Classes
RelationExtractionDLModel
def getConfigProtoBytes: Option[Array[Byte]]
ConfigProto from tensorflow, serialized into byte array.
ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString()

Definition Classes
RelationExtractionDLModel
def getCustomLabel(label: String): String
Gets the custom relation label for a given label.
Gets the custom relation label for a given label.

Definition Classes
RelationExtractionDLModel
def getCustomLabels: Map[String, String]
Gets all custom relation labels.
Gets all custom relation labels.

Definition Classes
RelationExtractionDLModel
final def getDefault[T](param: Param[T]): Option[T]

Definition Classes
Params
def getEngine: String

Definition Classes
HasEngine
def getInputCols: Array[String]

Definition Classes
HasInputAnnotationCols
def getLazyAnnotator: Boolean

Definition Classes
CanBeLazy
def getMaxSentenceLength: Int
Max sentence length to process (Default : 128)
Max sentence length to process (Default : 128)

Definition Classes
RelationExtractionDLModel
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 getPredictionThreshold: Float
Minimal activation of the target unit to encode a new relation instance (Default: 0.5f)
Minimal activation of the target unit to encode a new relation instance (Default: 0.5f)

Definition Classes
RelationExtractionDLModel
def getRelationPairsCaseSensitive: Boolean
Gets the case sensitivity of relation pairs
Gets the case sensitivity of relation pairs

Definition Classes
RelationExtractionDLModel
def getRelationTypePerPair: Map[String, Array[String]]
Get the lists of entity pairs allowed for a given relation
Get the lists of entity pairs allowed for a given relation

Definition Classes
RelationExtractionDLModel
def getRelationTypePerPairStr: String
Get a string representation of the lists of entity pairs allowed for a given relation
Get a string representation of the lists of entity pairs allowed for a given relation

Definition Classes
RelationExtractionDLModel
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 inExceptionMode: Boolean

Attributes
protected
Definition Classes
HasSafeAnnotate
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[AnnotatorType]
Input annotator types : CHUNK, DOCUMENT
Input annotator types : CHUNK, DOCUMENT

Definition Classes
RelationExtractionDLModel → 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 maxSentenceLength: IntParam
Max sentence length to process (Default : 128)
Max sentence length to process (Default : 128)

Definition Classes
RelationExtractionDLModel
def model: TensorflowBertRE

Definition Classes
RelationExtractionDLModel
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
RelationExtractionDLModel → ParamsAndFeaturesWritable
val optionalInputAnnotatorTypes: Array[String]

Definition Classes
HasInputAnnotationCols
val outputAnnotatorType: String
Output annotator type : CATEGORY
Output annotator type : CATEGORY

Definition Classes
RelationExtractionDLModel → HasOutputAnnotatorType
final val outputCol: Param[String]

Attributes
protected
Definition Classes
HasOutputAnnotationCol
lazy val params: Array[Param[_]]

Definition Classes
Params
var parent: Estimator[nlp.annotators.re.RelationExtractionDLModel]

Definition Classes
Model
var predictionThreshold: FloatParam
Minimal activation of the target unit to encode a new relation instance (Default: 0.5f)
Minimal activation of the target unit to encode a new relation instance (Default: 0.5f)

Definition Classes
RelationExtractionDLModel
var relationPairsCaseSensitive: BooleanParam
Determines whether relation pairs are case sensitive
Determines whether relation pairs are case sensitive

Definition Classes
RelationExtractionDLModel
def safeAnnotate(annotations: Seq[Annotation]): Seq[Annotation]
A protected method designed to safely annotate a sequence of Annotation objects by handling exceptions.
A protected method designed to safely annotate a sequence of Annotation objects by handling exceptions.
annotations
A sequence of Annotation.
returns
A sequence of Annotation objects after processing, potentially containing error annotations.

Attributes
protected
Definition Classes
HasSafeAnnotate
def save(path: String): Unit

Definition Classes
MLWritable
Annotations
@Since( "1.6.0" ) @throws( ... )
def set[T](feature: StructFeature[T], value: T): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
def set[K, V](feature: MapFeature[K, V], value: Map[K, V]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
def set[T](feature: SetFeature[T], value: Set[T]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
def set[T](feature: ArrayFeature[T], value: Array[T]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
final def set(paramPair: ParamPair[_]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
Params
final def set(param: String, value: Any): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
Params
final def set[T](param: Param[T], value: T): RelationExtractionDLModel.this.type

Definition Classes
Params
def setBatchSize(size: Int): RelationExtractionDLModel.this.type
Set the number of relations to process in a batch.
Set the number of relations to process in a batch. Using a larger value speeds up processing but requires more memory.

Definition Classes
RelationExtractionDLModel
def setCaseSensitive(value: Boolean): RelationExtractionDLModel.this.type

Definition Classes
HasCaseSensitiveProperties
def setCategoryNames(categoryNames: Array[String]): RelationExtractionDLModel.this.type
List of relation names
List of relation names

Definition Classes
RelationExtractionDLModel
def setConfigProtoBytes(bytes: Array[Int]): RelationExtractionDLModel.this.type
ConfigProto from tensorflow, serialized into byte array.
ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString()

Definition Classes
RelationExtractionDLModel
def setCustomLabels(labels: HashMap[String, String]): RelationExtractionDLModel.this.type

Definition Classes
RelationExtractionDLModel
def setCustomLabels(labels: Map[String, String]): RelationExtractionDLModel.this.type
Set custom relation labels
Set custom relation labels

Definition Classes
RelationExtractionDLModel
def setDefault[T](feature: StructFeature[T], value: () ⇒ T): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
def setDefault[K, V](feature: MapFeature[K, V], value: () ⇒ Map[K, V]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
def setDefault[T](feature: SetFeature[T], value: () ⇒ Set[T]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
def setDefault[T](feature: ArrayFeature[T], value: () ⇒ Array[T]): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
HasFeatures
final def setDefault(paramPairs: ParamPair[_]*): RelationExtractionDLModel.this.type

Attributes
protected
Definition Classes
Params
final def setDefault[T](param: Param[T], value: T): RelationExtractionDLModel.this.type

Attributes
protected[org.apache.spark.ml]
Definition Classes
Params
def setDoExceptionHandling(value: Boolean): RelationExtractionDLModel.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
final def setInputCols(value: String*): RelationExtractionDLModel.this.type

Definition Classes
HasInputAnnotationCols
def setInputCols(value: Array[String]): RelationExtractionDLModel.this.type

Definition Classes
HasInputAnnotationCols
def setLazyAnnotator(value: Boolean): RelationExtractionDLModel.this.type

Definition Classes
CanBeLazy
def setMaxSentenceLength(value: Int): RelationExtractionDLModel.this.type
Max sentence length to process (Default : 128)
Max sentence length to process (Default : 128)

Definition Classes
RelationExtractionDLModel
final def setOutputCol(value: String): RelationExtractionDLModel.this.type

Definition Classes
HasOutputAnnotationCol
def setParent(parent: Estimator[nlp.annotators.re.RelationExtractionDLModel]): nlp.annotators.re.RelationExtractionDLModel

Definition Classes
Model
def setPredictionThreshold(predictionThreshold: Float): RelationExtractionDLModel.this.type
Minimal activation of the target unit to encode a new relation instance (Default: 0.5f)
Minimal activation of the target unit to encode a new relation instance (Default: 0.5f)

Definition Classes
RelationExtractionDLModel
def setRelationPairsCaseSensitive(value: Boolean): RelationExtractionDLModel.this.type
Sets the case sensitivity of relation pairs
Sets the case sensitivity of relation pairs

Definition Classes
RelationExtractionDLModel
def setRelationTypePerPair(categories: HashMap[String, List[String]]): RelationExtractionDLModel.this.type
Set the lists of entity pairs allowed for a given relation
Set the lists of entity pairs allowed for a given relation

Definition Classes
RelationExtractionDLModel
def setRelationTypePerPair(categories: Map[String, Array[String]]): RelationExtractionDLModel.this.type
Set the lists of entity pairs allowed for a given relation
Set the lists of entity pairs allowed for a given relation

Definition Classes
RelationExtractionDLModel
def setStorageRef(value: String): RelationExtractionDLModel.this.type

Definition Classes
HasStorageRef
def setTensorflowModel(spark: SparkSession, tf: TensorflowWrapper): RelationExtractionDLModel.this.type

Definition Classes
RelationExtractionDLModel
def setVocabulary(value: Map[String, Int]): RelationExtractionDLModel.this.type
Vocabulary used to encode words to ids with WordPieceEncoder
Vocabulary used to encode words to ids with WordPieceEncoder

Definition Classes
RelationExtractionDLModel
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
def tokenizeSentence(sentence: Sentence): WordpieceTokenizedSentence

Definition Classes
RelationExtractionDLModel
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
RelationExtractionDLModel → RelationExtractionDLModel → Identifiable
def updateBertConfig: Unit

Definition Classes
RelationExtractionDLModel
def validate(schema: StructType): Boolean

Attributes
protected
Definition Classes
RawAnnotator
def validateStorageRef(dataset: Dataset[_], inputCols: Array[String], annotatorType: String): Unit

Definition Classes
HasStorageRef
val vocabulary: MapFeature[String, Int]
Vocabulary used to encode words to ids with WordPieceEncoder
Vocabulary used to encode words to ids with WordPieceEncoder

Definition Classes
RelationExtractionDLModel
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

Packages

RelationExtractionDLModel 

Companion object RelationExtractionDLModel

class RelationExtractionDLModel extends nlp.annotators.re.RelationExtractionDLModel

Example

Relation Extraction between body parts

Instance Constructors

Type Members

Value Members

Inherited from nlp.annotators.re.RelationExtractionDLModel

Inherited from CheckLicense

Inherited from HasSafeAnnotate[nlp.annotators.re.RelationExtractionDLModel]

Inherited from HandleExceptionParams

Inherited from HasEngine

Inherited from RelationEncoding

Inherited from HasSimpleAnnotate[nlp.annotators.re.RelationExtractionDLModel]

Inherited from HasCaseSensitiveProperties

Inherited from HasStorageRef

Inherited from WriteTensorflowModel

Inherited from AnnotatorModel[nlp.annotators.re.RelationExtractionDLModel]

Inherited from CanBeLazy

Inherited from RawAnnotator[nlp.annotators.re.RelationExtractionDLModel]

Inherited from HasOutputAnnotationCol

Inherited from HasInputAnnotationCols

Inherited from HasOutputAnnotatorType

Inherited from ParamsAndFeaturesWritable

Inherited from HasFeatures

Inherited from DefaultParamsWritable

Inherited from MLWritable

Inherited from Model[nlp.annotators.re.RelationExtractionDLModel]

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

Members

Parameter setters

Parameter getters

RelationExtractionDLModel