edu.stanford.nlp.ie.machinereading

Class BasicRelationExtractor

java.lang.Object

edu.stanford.nlp.ie.machinereading.BasicRelationExtractor

All Implemented Interfaces:

Extractor, Serializable

public class BasicRelationExtractor
extends Object
implements Extractor

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected LinearClassifier<String,String>	classifier
protected boolean	createUnrelatedRelations If true, it creates automatically negative examples by generating all combinations between EntityMentions in a sentence This is the common behavior, but for some domain (i.e., KBP) it must disabled.
int	featureCountThreshold
RelationFeatureFactory	featureFactory
String	relationExtractorClassifierType which classifier to use (can be 'linear' or 'svm')
protected RelationMentionFactory	relationMentionFactory
double	sigma strength of the prior on the linear classifier (passed to LinearClassifierFactory) or the C constant if relationExtractorClassifierType=svm

Constructor Summary

Constructors

Constructor and Description
BasicRelationExtractor(RelationFeatureFactory featureFac, Boolean createUnrelatedRelations, RelationMentionFactory factory)

Method Summary

Modifier and Type	Method and Description
void	annotate(Annotation dataset) Annotates the given dataset with the current model This works in place, i.e., it adds ExtractionObject objects to the sentences in the dataset To make sure you are not messing with gold annotation create a copy of the ExtractionDataSet first!
List<String>	annotateMulticlass(List<Datum<String,String>> testDatums)
void	annotateSentence(CoreMap sentence)
protected String	classOf(Datum<String,String> datum, ExtractionObject rel)
protected GeneralDataset<String,String>	createDataset(Annotation corpus)
protected Datum<String,String>	createDatum(RelationMention rel)
protected Datum<String,String>	createDatum(RelationMention rel, String label)
protected List<RelationMention>	extractAllRelations(CoreMap sentence) Predict a relation for each pair of entities in the sentence; including relations of type unrelated.
protected void	justificationOf(Datum<String,String> testDatum, PrintWriter pw, String label)
static BasicRelationExtractor	load(String modelPath)
protected Counter<String>	probabilityOf(Datum<String,String> testDatum)
protected static void	reportWeights(LinearClassifier<String,String> classifier, String classLabel)
void	save(String modelpath) Serializes this extractor to a file
void	setCreateUnrelatedRelations(boolean b)
void	setFeatureCountThreshold(int i)
void	setLoggerLevel(Level level)
void	setRelationExtractorClassifierType(String s)
void	setSigma(double d)
void	setValidator(LabelValidator lv)
void	train(Annotation sentences) Train on a list of ExtractionSentence containing labeled RelationMention objects
void	trainMulticlass(GeneralDataset<String,String> trainSet)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

classifier

protected LinearClassifier<String,String> classifier

featureCountThreshold

@Execution.Option(name="featureCountThreshold",
                  gloss="feature count threshold to apply to dataset")
public int featureCountThreshold

featureFactory

@Execution.Option(name="featureFactory",
                  gloss="Feature factory for the relation extractor")
public RelationFeatureFactory featureFactory

sigma

@Execution.Option(name="sigma",
                  gloss="strength of the prior on the linear classifier (passed to LinearClassifierFactory) or the C constant if relationExtractorClassifierType=svm")
public double sigma

strength of the prior on the linear classifier (passed to LinearClassifierFactory) or the C constant if relationExtractorClassifierType=svm

relationExtractorClassifierType

public String relationExtractorClassifierType

which classifier to use (can be 'linear' or 'svm')

createUnrelatedRelations

protected boolean createUnrelatedRelations

If true, it creates automatically negative examples by generating all combinations between EntityMentions in a sentence This is the common behavior, but for some domain (i.e., KBP) it must disabled. In these domains, the negative relation examples are created in the reader

relationMentionFactory

protected RelationMentionFactory relationMentionFactory

Constructor Detail

BasicRelationExtractor

public BasicRelationExtractor(RelationFeatureFactory featureFac,
                              Boolean createUnrelatedRelations,
                              RelationMentionFactory factory)

Method Detail

setValidator

public void setValidator(LabelValidator lv)

setRelationExtractorClassifierType

public void setRelationExtractorClassifierType(String s)

setFeatureCountThreshold

public void setFeatureCountThreshold(int i)

setSigma

public void setSigma(double d)

setCreateUnrelatedRelations

public void setCreateUnrelatedRelations(boolean b)

load

public static BasicRelationExtractor load(String modelPath)
                                   throws IOException,
                                          ClassNotFoundException

Throws:

IOException

ClassNotFoundException

save

public void save(String modelpath)
          throws IOException

Description copied from interface: Extractor

Serializes this extractor to a file

Specified by:

save in interface Extractor

Parameters:

modelpath - where to save the extractor

Throws:

IOException

train

public void train(Annotation sentences)

Train on a list of ExtractionSentence containing labeled RelationMention objects

Specified by:

train in interface Extractor

Parameters:

sentences - dataset to train from (this should already have annotations and will typically be created by a reader)

trainMulticlass

public void trainMulticlass(GeneralDataset<String,String> trainSet)

reportWeights

protected static void reportWeights(LinearClassifier<String,String> classifier,
                                    String classLabel)

classOf

protected String classOf(Datum<String,String> datum,
                         ExtractionObject rel)

probabilityOf

protected Counter<String> probabilityOf(Datum<String,String> testDatum)

justificationOf

protected void justificationOf(Datum<String,String> testDatum,
                               PrintWriter pw,
                               String label)

extractAllRelations

protected List<RelationMention> extractAllRelations(CoreMap sentence)

Predict a relation for each pair of entities in the sentence; including relations of type unrelated. This creates new RelationMention objects!

annotateMulticlass

public List<String> annotateMulticlass(List<Datum<String,String>> testDatums)

annotateSentence

public void annotateSentence(CoreMap sentence)

annotate

public void annotate(Annotation dataset)

Description copied from interface: Extractor

Annotates the given dataset with the current model This works in place, i.e., it adds ExtractionObject objects to the sentences in the dataset To make sure you are not messing with gold annotation create a copy of the ExtractionDataSet first!

Specified by:

annotate in interface Extractor

Parameters:

dataset - dataset to annotate

createDataset

protected GeneralDataset<String,String> createDataset(Annotation corpus)

createDatum

protected Datum<String,String> createDatum(RelationMention rel)

createDatum

protected Datum<String,String> createDatum(RelationMention rel,
                                           String label)

setLoggerLevel

public void setLoggerLevel(Level level)

Specified by:

setLoggerLevel in interface Extractor