├── ade
    ├── ade.option
    ├── ADEsentence.h
    ├── Relation.h
    ├── BestPerformance.h
    ├── Tool.h
    ├── Makefile
    ├── N3Lhelper.h
    ├── .project
    ├── .settings
    │   └── language.settings.xml
    ├── Example.h
    ├── Entity.h
    ├── .cproject
    ├── ade.cpp
    ├── Options.h
    ├── CNN.h
    ├── Attention_ZhouACL2016.h
    ├── utils.h
    ├── Argument_helper.h
    └── NNade3.h
├── bb3
    ├── bb3.option
    ├── Document.h
    ├── NerExample.h
    ├── Tool.h
    ├── N3Lhelper.h
    ├── Makefile
    ├── .project
    ├── .settings
    │   └── language.settings.xml
    ├── Relation.h
    ├── Example.h
    ├── Entity.h
    ├── bb3.cpp
    ├── .cproject
    ├── Options.h
    ├── CNN.h
    ├── Attention_ZhouACL2016.h
    ├── utils.h
    └── Argument_helper.h
├── .gitattributes
└── README.md


/ade/ade.option:
--------------------------------------------------------------------------------
 1 | wordCutOff = 0
 2 | maxIter = 300
 3 | adaAlpha = 0.03
 4 | dropProb = 0
 5 | wordEmbSize = 200
 6 | otherEmbSize = 25
 7 | rnnHiddenSize = 100
 8 | hiddenSize = 100
 9 | evalPerIter = 1
10 | wordEmbFineTune = true
11 | abbrPath = 
12 | puncPath = 
13 | verboseIter = 1
14 | embFile = 
15 | wordcontext = 0
16 | regParameter = 0.00000001
17 | batchSize = 1
18 | poolType = 0
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/bb3/bb3.option:
--------------------------------------------------------------------------------
 1 | wordCutOff = 0
 2 | maxIter = 300
 3 | adaAlpha = 0.03
 4 | dropProb = 0
 5 | wordEmbSize = 200
 6 | otherEmbSize = 25
 7 | rnnHiddenSize = 100
 8 | hiddenSize = 100
 9 | evalPerIter = 1
10 | wordEmbFineTune = true
11 | abbrPath = 
12 | puncPath = 
13 | verboseIter = 1
14 | embFile = 
15 | wordcontext = 0
16 | regParameter = 0.00000001
17 | batchSize = 1
18 | poolType = 0
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | 
 7 | # Standard to msysgit
 8 | *.doc	 diff=astextplain
 9 | *.DOC	 diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot  diff=astextplain
13 | *.DOT  diff=astextplain
14 | *.pdf  diff=astextplain
15 | *.PDF	 diff=astextplain
16 | *.rtf	 diff=astextplain
17 | *.RTF	 diff=astextplain
18 | 


--------------------------------------------------------------------------------
/ade/ADEsentence.h:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #ifndef ADESENTENCE_H_
 4 | #define ADESENTENCE_H_
 5 | 
 6 | #include <string>
 7 | #include "Entity.h"
 8 | #include "Relation.h"
 9 | 
10 | using namespace std;
11 | 
12 | 
13 | class ADEsentence {
14 | public:
15 | 	ADEsentence() {
16 | 		offset = -1;
17 | 	}
18 | 
19 | 	void clear() {
20 | 		entities.clear();
21 | 		relations.clear();
22 | 		text.clear();
23 | 		offset = -1;
24 | 	}
25 | 
26 | 	vector<Entity> entities;
27 | 	vector<Relation> relations;
28 | 	string text;
29 | 	int offset;
30 | };
31 | 
32 | #endif /* ADESENTENCE_H_ */
33 | 


--------------------------------------------------------------------------------
/bb3/Document.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BiocDocument.h
 3 |  *
 4 |  *  Created on: Dec 19, 2015
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef DOCUMENT_H_
 9 | #define DOCUMENT_H_
10 | 
11 | #include <string>
12 | #include "Entity.h"
13 | #include "Relation.h"
14 | #include "Sent.h"
15 | 
16 | using namespace std;
17 | 
18 | 
19 | class Document {
20 | public:
21 | 	Document() {
22 | 
23 | 	}
24 | /*	virtual ~BiocDocument() {
25 | 
26 | 	}*/
27 | 
28 | 	string id;
29 | 	vector<Entity> entities;
30 | 	vector<Relation> relations;
31 | 	vector<fox::Sent> sents;
32 | 	int maxParagraphId;
33 | };
34 | 
35 | #endif /* DOCUMENT_H_ */
36 | 


--------------------------------------------------------------------------------
/bb3/NerExample.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Example.h
 3 |  *
 4 |  *  Created on: Mar 17, 2015
 5 |  *      Author: mszhang
 6 |  */
 7 | 
 8 | #ifndef SRC_NerEXAMPLE_H_
 9 | #define SRC_NerEXAMPLE_H_
10 | #include <vector>
11 | 
12 | using namespace std;
13 | 
14 | class NerExample {
15 | 
16 | public:
17 |   vector<int> m_labels;
18 |   int goldLabel;
19 | 
20 |   vector<int> _words;
21 |   vector<int> _postags;
22 | 
23 |   int _prior_ner;
24 | 
25 |   int _current_idx;
26 | 
27 | 
28 | public:
29 |   NerExample()
30 |   {
31 | 
32 |   }
33 | /*  virtual ~Example()
34 |   {
35 | 
36 |   }*/
37 | 
38 | 
39 | 
40 | };
41 | 
42 | #endif /* SRC_EXAMPLE_H_ */
43 | 


--------------------------------------------------------------------------------
/ade/Relation.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * RelationEntity.h
 3 |  *
 4 |  *  Created on: Mar 9, 2016
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef RELATION_H_
 9 | #define RELATION_H_
10 | 
11 | #include <string>
12 | #include <sstream>
13 | 
14 | using namespace std;
15 | 
16 | // non-directional live-in relation in mention level
17 | class Relation {
18 | 
19 | public:
20 | 
21 | 	  Entity entity1;
22 | 	  Entity entity2;
23 | 
24 | 	  bool equals(const Relation& another) const {
25 | 		  if(entity1.equals(another.entity1) && entity2.equals(another.entity2))
26 | 			  return true;
27 | 		  else
28 | 			  return false;
29 | 	  }
30 | };
31 | 
32 | 
33 | 
34 | #endif /* RELATION_H_ */
35 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | This is a C++ implement of extracting biomedical entities and relations from raw text.
 2 | Please see the publication "A neural joint model for entity and relation extraction from biomedical text" for details.
 3 | If you have any question, pleae feel free to contact me.
 4 | 
 5 | Citation in BibTex:
 6 | 
 7 | @Article{Li2017,
 8 | author="Li, Fei and Zhang, Meishan and Fu, Guohong and Ji, Donghong",
 9 | title="A neural joint model for entity and relation extraction from biomedical text",
10 | journal="BMC Bioinformatics",
11 | year="2017",
12 | volume="18",
13 | number="1",
14 | pages="198",
15 | doi="10.1186/s12859-017-1609-9",
16 | url="http://dx.doi.org/10.1186/s12859-017-1609-9"
17 | }
18 | 


--------------------------------------------------------------------------------
/ade/BestPerformance.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BestPerformance.h
 3 |  *
 4 |  *  Created on: Sep 16, 2016
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef BESTPERFORMANCE_H_
 9 | #define BESTPERFORMANCE_H_
10 | 
11 | class BestPerformance {
12 | public:
13 | 	BestPerformance() {
14 | 
15 | 	}
16 | 	double dev_pEntity = 0;
17 | 	double dev_rEntity = 0;
18 | 	double dev_f1Entity = 0;
19 | 	double dev_pRelation = 0;
20 | 	double dev_rRelation = 0;
21 | 	double dev_f1Relation = 0;
22 | 
23 | 	double test_pEntity = 0;
24 | 	double test_rEntity = 0;
25 | 	double test_f1Entity = 0;
26 | 	double test_pRelation = 0;
27 | 	double test_rRelation = 0;
28 | 	double test_f1Relation = 0;
29 | };
30 | 
31 | #endif /* BESTPERFORMANCE_H_ */
32 | 


--------------------------------------------------------------------------------
/ade/Tool.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Tool.h
 3 |  *
 4 |  *  Created on: Dec 27, 2015
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef TOOL_H_
 9 | #define TOOL_H_
10 | 
11 | #include "SentSplitter.h"
12 | #include "Tokenizer.h"
13 | #include "Options.h"
14 | #include "Word2Vec.h"
15 | #include "FoxUtil.h"
16 | 
17 | 
18 | class Tool {
19 | public:
20 | 	Options option;
21 | 	fox::SentSplitter sentSplitter;
22 | 	fox::Tokenizer tokenizer;
23 | 	fox::Word2Vec* w2v;
24 | 
25 | 
26 | 	Tool(Options option) : option(option), sentSplitter(NULL, &option.abbrPath),
27 | 			tokenizer(&option.puncPath) {
28 | 
29 | 		w2v = new fox::Word2Vec();
30 | 
31 | 	}
32 | 	virtual ~Tool() {
33 | 		delete w2v;
34 | 	}
35 | 
36 | };
37 | 
38 | 
39 | 
40 | #endif /* TOOL_H_ */
41 | 


--------------------------------------------------------------------------------
/bb3/Tool.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Tool.h
 3 |  *
 4 |  *  Created on: Dec 27, 2015
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef TOOL_H_
 9 | #define TOOL_H_
10 | 
11 | #include "SentSplitter.h"
12 | #include "Tokenizer.h"
13 | #include "Options.h"
14 | #include "Word2Vec.h"
15 | #include "FoxUtil.h"
16 | 
17 | 
18 | class Tool {
19 | public:
20 | 	Options option;
21 | 	fox::SentSplitter sentSplitter;
22 | 	fox::Tokenizer tokenizer;
23 | 	fox::Word2Vec* w2v;
24 | 
25 | 
26 | 	Tool(Options option) : option(option), sentSplitter(NULL, &option.abbrPath),
27 | 			tokenizer(&option.puncPath) {
28 | 
29 | 		w2v = new fox::Word2Vec();
30 | 
31 | 	}
32 | 	virtual ~Tool() {
33 | 		delete w2v;
34 | 	}
35 | 
36 | };
37 | 
38 | 
39 | 
40 | #endif /* TOOL_H_ */
41 | 


--------------------------------------------------------------------------------
/ade/Makefile:
--------------------------------------------------------------------------------
 1 | cc=g++
 2 | 
 3 | #cflags = -O0 -g3 -w \
 4 | 	-I/home/fox/project/FoxUtil \
 5 | 	-msse3 -I /home/fox/Downloads/mshadow-master/mshadow -DMSHADOW_USE_CUDA=0 -DMSHADOW_USE_CBLAS=1 -DMSHADOW_USE_MKL=0 \
 6 | 	-I/home/fox/Downloads/LibN3L-master -DUSE_CUDA=0 \
 7 | 	
 8 | cflags = -O3 -w \
 9 | 	-I/home/fox/project/FoxUtil \
10 | 	-msse3 -I /home/fox/Downloads/mshadow-master/mshadow -DMSHADOW_USE_CUDA=0 -DMSHADOW_USE_CBLAS=1 -DMSHADOW_USE_MKL=0 \
11 | 	-I/home/fox/Downloads/LibN3L-master -DUSE_CUDA=0 \
12 | 	-static-libgcc -static-libstdc++\
13 | 
14 | libs = -lm -lopenblas -Wl,-rpath,./ \
15 |  
16 | all: ade
17 | 
18 | ade: ade.cpp Entity.h Relation.h Tool.h Options.h utils.h 
19 | 	$(cc) -o ade ade.cpp $(cflags) $(libs)
20 | 
21 | 	
22 | 
23 | 
24 | 
25 | 
26 | clean:
27 | 	rm -rf *.o
28 | 	rm -rf ade
29 | 
30 | 


--------------------------------------------------------------------------------
/ade/N3Lhelper.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * N3Lhelper.h
 3 |  *
 4 |  *  Created on: Dec 27, 2015
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef N3LHELPER_H_
 9 | #define N3LHELPER_H_
10 | 
11 | #include "N3L.h"
12 | 
13 | using namespace std;
14 | 
15 | 
16 | void alphabet2vectormap(const Alphabet& alphabet, vector<string>& vector, map<string, int>& IDs) {
17 | 
18 | 	for (int j = 0; j < alphabet.size(); ++j) {
19 | 		string str = alphabet.from_id(j);
20 | 		vector.push_back(str);
21 | 		IDs.insert(map<string, int>::value_type(str, j));
22 | 	}
23 | 
24 | }
25 | 
26 | template<typename T>
27 | void array2NRMat(T * array, int sizeX, int sizeY, NRMat<T>& mat) {
28 | 	for(int i=0;i<sizeX;i++) {
29 | 		for(int j=0;j<sizeY;j++) {
30 | 			mat[i][j] = *(array+i*sizeY+j);
31 | 		}
32 | 	}
33 | }
34 | 
35 | 
36 | 
37 | #endif /* N3LHELPER_H_ */
38 | 


--------------------------------------------------------------------------------
/bb3/N3Lhelper.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * N3Lhelper.h
 3 |  *
 4 |  *  Created on: Dec 27, 2015
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef N3LHELPER_H_
 9 | #define N3LHELPER_H_
10 | 
11 | #include "N3L.h"
12 | 
13 | using namespace std;
14 | 
15 | 
16 | void alphabet2vectormap(const Alphabet& alphabet, vector<string>& vector, map<string, int>& IDs) {
17 | 
18 | 	for (int j = 0; j < alphabet.size(); ++j) {
19 | 		string str = alphabet.from_id(j);
20 | 		vector.push_back(str);
21 | 		IDs.insert(map<string, int>::value_type(str, j));
22 | 	}
23 | 
24 | }
25 | 
26 | template<typename T>
27 | void array2NRMat(T * array, int sizeX, int sizeY, NRMat<T>& mat) {
28 | 	for(int i=0;i<sizeX;i++) {
29 | 		for(int j=0;j<sizeY;j++) {
30 | 			mat[i][j] = *(array+i*sizeY+j);
31 | 		}
32 | 	}
33 | }
34 | 
35 | 
36 | 
37 | #endif /* N3LHELPER_H_ */
38 | 


--------------------------------------------------------------------------------
/bb3/Makefile:
--------------------------------------------------------------------------------
 1 | cc=g++
 2 | 
 3 | #cflags = -O0 -g3 -w \
 4 | 	-I/home/fox/project/FoxUtil \
 5 | 	-msse3 -I /home/fox/Downloads/mshadow-master/mshadow -DMSHADOW_USE_CUDA=0 -DMSHADOW_USE_CBLAS=1 -DMSHADOW_USE_MKL=0 \
 6 | 	-I/home/fox/Downloads/LibN3L-master -DUSE_CUDA=0 \
 7 | 	
 8 | cflags = -O3 -w \
 9 | 	-I/home/fox/project/FoxUtil \
10 | 	-msse3 -I /home/fox/Downloads/mshadow-master/mshadow -DMSHADOW_USE_CUDA=0 -DMSHADOW_USE_CBLAS=1 -DMSHADOW_USE_MKL=0 \
11 | 	-I/home/fox/Downloads/LibN3L-master -DUSE_CUDA=0 \
12 | 	-static-libgcc -static-libstdc++\
13 | 
14 | libs = -lm -lopenblas -Wl,-rpath,./ \
15 |  
16 | all: bb3
17 | 
18 | bb3: bb3.cpp Entity.h Relation.h Document.h Tool.h Options.h utils.h NNbb3.h 
19 | 	$(cc) -o bb3 bb3.cpp $(cflags) $(libs)
20 | 
21 | 	
22 | 
23 | 
24 | 
25 | 
26 | clean:
27 | 	rm -rf *.o
28 | 	rm -rf bb3
29 | 
30 | 


--------------------------------------------------------------------------------
/ade/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>ade</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
10 | 			<triggers>clean,full,incremental,</triggers>
11 | 			<arguments>
12 | 			</arguments>
13 | 		</buildCommand>
14 | 		<buildCommand>
15 | 			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
16 | 			<triggers>full,incremental,</triggers>
17 | 			<arguments>
18 | 			</arguments>
19 | 		</buildCommand>
20 | 	</buildSpec>
21 | 	<natures>
22 | 		<nature>org.eclipse.cdt.core.cnature</nature>
23 | 		<nature>org.eclipse.cdt.core.ccnature</nature>
24 | 		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
25 | 		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
26 | 	</natures>
27 | </projectDescription>
28 | 


--------------------------------------------------------------------------------
/bb3/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>bb3</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
10 | 			<triggers>clean,full,incremental,</triggers>
11 | 			<arguments>
12 | 			</arguments>
13 | 		</buildCommand>
14 | 		<buildCommand>
15 | 			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
16 | 			<triggers>full,incremental,</triggers>
17 | 			<arguments>
18 | 			</arguments>
19 | 		</buildCommand>
20 | 	</buildSpec>
21 | 	<natures>
22 | 		<nature>org.eclipse.cdt.core.cnature</nature>
23 | 		<nature>org.eclipse.cdt.core.ccnature</nature>
24 | 		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
25 | 		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
26 | 	</natures>
27 | </projectDescription>
28 | 


--------------------------------------------------------------------------------
/ade/.settings/language.settings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <project>
 3 | 	<configuration id="cdt.managedbuild.toolchain.gnu.base.1790711008" name="Default">
 4 | 		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
 5 | 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 6 | 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 7 | 			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuildCommandParser" id="org.eclipse.cdt.managedbuilder.core.GCCBuildCommandParser" keep-relative-paths="false" name="CDT GCC Build Output Parser" parameter="(gcc)|([gc]\+\+)|(clang)" prefer-non-shared="true"/>
 8 | 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.GCCBuiltinSpecsDetector" ref="shared-provider"/>
 9 | 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
10 | 		</extension>
11 | 	</configuration>
12 | </project>
13 | 


--------------------------------------------------------------------------------
/bb3/.settings/language.settings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <project>
 3 | 	<configuration id="cdt.managedbuild.toolchain.gnu.base.1720226921" name="Default">
 4 | 		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
 5 | 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 6 | 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 7 | 			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuildCommandParser" id="org.eclipse.cdt.managedbuilder.core.GCCBuildCommandParser" keep-relative-paths="false" name="CDT GCC Build Output Parser" parameter="(gcc)|([gc]\+\+)|(clang)" prefer-non-shared="true"/>
 8 | 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.GCCBuiltinSpecsDetector" ref="shared-provider"/>
 9 | 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
10 | 		</extension>
11 | 	</configuration>
12 | </project>
13 | 


--------------------------------------------------------------------------------
/bb3/Relation.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * RelationEntity.h
 3 |  *
 4 |  *  Created on: Mar 9, 2016
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef RELATION_H_
 9 | #define RELATION_H_
10 | 
11 | #include <string>
12 | #include <sstream>
13 | 
14 | using namespace std;
15 | 
16 | // non-directional live-in relation in mention level
17 | class Relation {
18 | 
19 | public:
20 | 	string id;
21 | 	  string idBacteria;
22 | 	  string idLocation;
23 | 
24 | 	  Entity bacteria;
25 | 	  Entity location;
26 | 
27 | 	  bool equals(const Relation& another) {
28 | 		  if(bacteria.equals(another.bacteria) && location.equals(another.location))
29 | 			  return true;
30 | 		  else
31 | 			  return false;
32 | 	  }
33 | 
34 | 	  void setId(int _id) {
35 | 		stringstream ss;
36 | 		ss<<"R"<<_id;
37 | 		id = ss.str();
38 | 	  }
39 | 
40 | 	  void setBacId(const string& bacId) {
41 | 		  idBacteria = bacId;
42 | 		  bacteria.id = bacId;
43 | 	  }
44 | 
45 | 	  void setLocId(const string& locId) {
46 | 		  idLocation = locId;
47 | 		  location.id = locId;
48 | 	  }
49 | };
50 | 
51 | 
52 | 
53 | #endif /* RELATION_H_ */
54 | 


--------------------------------------------------------------------------------
/bb3/Example.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Example.h
 3 |  *
 4 |  *  Created on: Mar 17, 2015
 5 |  *      Author: mszhang
 6 |  */
 7 | 
 8 | #ifndef SRC_EXAMPLE_H_
 9 | #define SRC_EXAMPLE_H_
10 | #include <vector>
11 | #include "N3L.h"
12 | 
13 | using namespace std;
14 | 
15 | class Example {
16 | 
17 | public:
18 | 	//used by ner
19 |   vector<int> _nerLabels;
20 |   int nerGoldLabel;
21 | 
22 |   vector<int> _words;
23 |   vector<int> _postags;
24 |   vector< vector<int> > _seq_chars;
25 | 
26 |   int _prior_ner;
27 | 
28 |   int _current_idx;
29 | 
30 |   // used by relation
31 |   bool _isRelation;
32 | 
33 |   vector<int> _relLabels;
34 |   int relGoldLabel;
35 | 
36 |   vector<int> _deps;
37 |   vector<int> _ners;
38 | 
39 |   vector<int> _idxOnSDP_E12A;
40 |   vector<int> _idxOnSDP_E22A;
41 | 
42 |   hash_set<int> _idx_e1;
43 |   hash_set<int> _idx_e2;
44 | 
45 | public:
46 |   Example(bool isrel)
47 |   {
48 | 	  nerGoldLabel = -1;
49 | 	  _prior_ner = -1;
50 | 	  _current_idx = -1;
51 | 
52 | 	  _isRelation = isrel;
53 | 
54 | 	  relGoldLabel = -1;
55 | 
56 |   }
57 | /*  virtual ~Example()
58 |   {
59 | 
60 |   }*/
61 | 
62 | 
63 | 
64 | };
65 | 
66 | #endif /* SRC_EXAMPLE_H_ */
67 | 


--------------------------------------------------------------------------------
/ade/Example.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Example.h
 3 |  *
 4 |  *  Created on: Mar 17, 2015
 5 |  *      Author: mszhang
 6 |  */
 7 | 
 8 | #ifndef SRC_EXAMPLE_H_
 9 | #define SRC_EXAMPLE_H_
10 | #include <vector>
11 | #include "N3L.h"
12 | 
13 | using namespace std;
14 | 
15 | class Example {
16 | 
17 | public:
18 | 	//used by ner
19 |   vector<int> _nerLabels;
20 |   int nerGoldLabel;
21 | 
22 |   vector<int> _words;
23 |   vector<int> _postags;
24 |   vector< vector<int> > _seq_chars;
25 | 
26 |   int _prior_ner;
27 | 
28 |   int _current_idx;
29 | 
30 |   // used by relation
31 |   bool _isRelation;
32 | 
33 |   vector<int> _relLabels;
34 |   int relGoldLabel;
35 | 
36 |   vector<int> _deps;
37 |   vector<int> _ners;
38 | 
39 |   vector<int> _idxOnSDP_E12A;
40 |   vector<int> _idxOnSDP_E22A;
41 | 
42 |   hash_set<int> _idx_e1;
43 |   hash_set<int> _idx_e2;
44 | 
45 |   vector<int> _between_words;
46 | 
47 | public:
48 |   Example(bool isrel)
49 |   {
50 | 	  nerGoldLabel = -1;
51 | 	  _prior_ner = -1;
52 | 	  _current_idx = -1;
53 | 
54 | 	  _isRelation = isrel;
55 | 
56 | 	  relGoldLabel = -1;
57 | 
58 |   }
59 | /*  virtual ~Example()
60 |   {
61 | 
62 |   }*/
63 | 
64 | 
65 | 
66 | };
67 | 
68 | #endif /* SRC_EXAMPLE_H_ */
69 | 


--------------------------------------------------------------------------------
/bb3/Entity.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Entity.h
 3 |  *
 4 |  *  Created on: Mar 9, 2016
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef ENTITY_H_
 9 | #define ENTITY_H_
10 | 
11 | #include <string>
12 | #include <sstream>
13 | 
14 | using namespace std;
15 | 
16 | class Entity {
17 | public:
18 | 	  string id; // id is unique in a document
19 | 	  string type;
20 | 	  int begin; // the first character offset at "doc level"
21 | 	  string text;
22 | 	  int end; // the last character offset+1 at "doc level"
23 | 
24 | 	  int tkStart; // the token index that this segment starts
25 | 	  int tkEnd; // the token index that this segment ends.
26 | 
27 | 	// for non-continuous mention
28 | 	  int begin2;
29 | 	  int end2;
30 | 
31 | 	  int sentIdx; // the sentence index which this entity belongs to
32 | 
33 | 	Entity() {
34 | 		id = "-1";
35 | 		type = "";
36 | 		begin = -1;
37 | 		text = "";
38 | 		end = -1;
39 | 		tkStart = -1;
40 | 		tkEnd = -1;
41 | 
42 | 		begin2 = -1;
43 | 		end2 = -1;
44 | 
45 | 		sentIdx = -1;
46 | 
47 | 	}
48 | 
49 | 	bool equals(const Entity& another) const {
50 | 		if(type == another.type && begin == another.begin && end == another.end)
51 | 			return true;
52 | 		else
53 | 			return false;
54 | 	}
55 | 
56 | 	  void setId(int _id) {
57 | 		stringstream ss;
58 | 		ss<<"T"<<_id;
59 | 		id = ss.str();
60 | 	  }
61 | };
62 | 
63 | 
64 | 
65 | #endif /* ENTITY_H_ */
66 | 


--------------------------------------------------------------------------------
/ade/Entity.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Entity.h
 3 |  *
 4 |  *  Created on: Mar 9, 2016
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #ifndef ENTITY_H_
 9 | #define ENTITY_H_
10 | 
11 | #include <string>
12 | #include <sstream>
13 | 
14 | using namespace std;
15 | 
16 | class Entity {
17 | public:
18 | 	  string id; // id is unique in a document
19 | 	  string type;
20 | 	  int begin; // the first character offset at "doc level"
21 | 	  string text;
22 | 	  int end; // the last character offset+1 at "doc level"
23 | 
24 | 	  int tkStart; // the token index that this segment starts
25 | 	  int tkEnd; // the token index that this segment ends.
26 | 
27 | 	// for non-continuous mention
28 | 	  int begin2;
29 | 	  int end2;
30 | 
31 | 	  int sentIdx; // the sentence index which this entity belongs to
32 | 
33 | 	Entity() {
34 | 		id = "-1";
35 | 		type = "";
36 | 		begin = -1;
37 | 		text = "";
38 | 		end = -1;
39 | 		tkStart = -1;
40 | 		tkEnd = -1;
41 | 
42 | 		begin2 = -1;
43 | 		end2 = -1;
44 | 
45 | 		sentIdx = -1;
46 | 
47 | 	}
48 | 
49 | 	bool equals(const Entity& another) const {
50 | 		if(type == another.type && begin == another.begin && end == another.end)
51 | 			return true;
52 | 		else
53 | 			return false;
54 | 	}
55 | 
56 | 	bool equalsBoundary(const Entity& another) const {
57 | 		if(begin == another.begin && end == another.end)
58 | 			return true;
59 | 		else
60 | 			return false;
61 | 	}
62 | 
63 | 	bool equalsType(const Entity& another) const {
64 | 		if(type == another.type)
65 | 			return true;
66 | 		else
67 | 			return false;
68 | 	}
69 | 
70 | 
71 | };
72 | 
73 | 
74 | 
75 | #endif /* ENTITY_H_ */
76 | 


--------------------------------------------------------------------------------
/bb3/bb3.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * cdr.cpp
 3 |  *
 4 |  *  Created on: Dec 19, 2015
 5 |  *      Author: fox
 6 |  */
 7 | 
 8 | #include <vector>
 9 | #include "utils.h"
10 | #include "FoxUtil.h"
11 | #include <iostream>
12 | #include "Token.h"
13 | #include "SentSplitter.h"
14 | #include "Tokenizer.h"
15 | #include "N3L.h"
16 | #include "Argument_helper.h"
17 | #include "Options.h"
18 | #include "Tool.h"
19 | 
20 | 
21 | #include "NNbb3.h"
22 | 
23 | 
24 | 
25 | using namespace std;
26 | 
27 | 
28 | int main(int argc, char **argv)
29 | {
30 | #if USE_CUDA==1
31 |   InitTensorEngine();
32 | #else
33 |   InitTensorEngine<cpu>();
34 | #endif
35 | 
36 | 
37 | 	string optionFile;
38 | 	string trainFile;
39 | 	string devFile;
40 | 	string testFile;
41 | 	string outputFile;
42 | 	string trainNlpFile;
43 | 	string devNlpFile;
44 | 	string testNlpFile;
45 | 
46 | 
47 | 
48 | 	dsr::Argument_helper ah;
49 | 	ah.new_named_string("train", "", "", "", trainFile);
50 | 	ah.new_named_string("dev", "", "", "", devFile);
51 | 	ah.new_named_string("test", "", "", "", testFile);
52 | 	ah.new_named_string("option", "", "", "", optionFile);
53 | 	ah.new_named_string("output", "", "", "", outputFile);
54 | 	ah.new_named_string("trainnlp", "", "", "", trainNlpFile);
55 | 	ah.new_named_string("devnlp", "", "", "", devNlpFile);
56 | 	ah.new_named_string("testnlp", "", "", "", testNlpFile);
57 | 
58 | 
59 | 	ah.process(argc, argv);
60 | 	cout<<"train file: " <<trainFile <<endl;
61 | 	cout<<"dev file: "<<devFile<<endl;
62 | 	cout<<"test file: "<<testFile<<endl;
63 | 
64 | 	cout<<"trainnlp file: "<<trainNlpFile<<endl;
65 | 	cout<<"devnlp file: "<<devNlpFile<<endl;
66 | 	cout<<"testnlp file: "<<testNlpFile<<endl;
67 | 
68 | 
69 | 	Options options;
70 | 	options.load(optionFile);
71 | 
72 | 	if(!outputFile.empty())
73 | 		options.output = outputFile;
74 | 
75 | 	options.showOptions();
76 | 
77 | 	Tool tool(options);
78 | 
79 | 
80 | 	NNbb3 nnbb(options);
81 | 
82 | 	nnbb.trainAndTest(trainFile, devFile, testFile, tool,
83 | 			trainNlpFile, devNlpFile, testNlpFile);
84 | 
85 | 
86 | 
87 | #if USE_CUDA==1
88 |   ShutdownTensorEngine();
89 | #else
90 |   ShutdownTensorEngine<cpu>();
91 | #endif
92 | 
93 |     return 0;
94 | 
95 | }
96 | 
97 | 


--------------------------------------------------------------------------------
/ade/.cproject:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
 3 | 	<storageModule moduleId="org.eclipse.cdt.core.settings">
 4 | 		<cconfiguration id="cdt.managedbuild.toolchain.gnu.base.1790711008">
 5 | 			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.toolchain.gnu.base.1790711008" moduleId="org.eclipse.cdt.core.settings" name="Default">
 6 | 				<externalSettings/>
 7 | 				<extensions>
 8 | 					<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
 9 | 					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
10 | 					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
11 | 					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
12 | 					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
13 | 					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
14 | 				</extensions>
15 | 			</storageModule>
16 | 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
17 | 				<configuration buildProperties="" id="cdt.managedbuild.toolchain.gnu.base.1790711008" name="Default" parent="org.eclipse.cdt.build.core.emptycfg">
18 | 					<folderInfo id="cdt.managedbuild.toolchain.gnu.base.1790711008.1989662665" name="/" resourcePath="">
19 | 						<toolChain id="cdt.managedbuild.toolchain.gnu.base.1089545287" name="Linux GCC" superClass="cdt.managedbuild.toolchain.gnu.base">
20 | 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="cdt.managedbuild.target.gnu.platform.base.519493264" name="Debug Platform" osList="linux,hpux,aix,qnx" superClass="cdt.managedbuild.target.gnu.platform.base"/>
21 | 							<builder id="cdt.managedbuild.target.gnu.builder.base.1868780153" managedBuildOn="false" name="Gnu Make Builder.Default" superClass="cdt.managedbuild.target.gnu.builder.base"/>
22 | 							<tool id="cdt.managedbuild.tool.gnu.archiver.base.364051869" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
23 | 							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.base.1850119211" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.base"/>
24 | 							<tool id="cdt.managedbuild.tool.gnu.c.compiler.base.224251250" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.base"/>
25 | 							<tool id="cdt.managedbuild.tool.gnu.c.linker.base.1742773957" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.base"/>
26 | 							<tool id="cdt.managedbuild.tool.gnu.cpp.linker.base.557026013" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.base"/>
27 | 							<tool id="cdt.managedbuild.tool.gnu.assembler.base.291753369" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.base"/>
28 | 						</toolChain>
29 | 					</folderInfo>
30 | 				</configuration>
31 | 			</storageModule>
32 | 			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
33 | 		</cconfiguration>
34 | 	</storageModule>
35 | 	<storageModule moduleId="scannerConfiguration">
36 | 		<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
37 | 	</storageModule>
38 | 	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
39 | 		<project id="ade.null.400587892" name="ade"/>
40 | 	</storageModule>
41 | 	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
42 | </cproject>
43 | 


--------------------------------------------------------------------------------
/bb3/.cproject:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
 3 | 	<storageModule moduleId="org.eclipse.cdt.core.settings">
 4 | 		<cconfiguration id="cdt.managedbuild.toolchain.gnu.base.1720226921">
 5 | 			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.toolchain.gnu.base.1720226921" moduleId="org.eclipse.cdt.core.settings" name="Default">
 6 | 				<externalSettings/>
 7 | 				<extensions>
 8 | 					<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
 9 | 					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
10 | 					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
11 | 					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
12 | 					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
13 | 					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
14 | 				</extensions>
15 | 			</storageModule>
16 | 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
17 | 				<configuration buildProperties="" id="cdt.managedbuild.toolchain.gnu.base.1720226921" name="Default" parent="org.eclipse.cdt.build.core.emptycfg">
18 | 					<folderInfo id="cdt.managedbuild.toolchain.gnu.base.1720226921.1986044235" name="/" resourcePath="">
19 | 						<toolChain id="cdt.managedbuild.toolchain.gnu.base.951937389" name="Linux GCC" superClass="cdt.managedbuild.toolchain.gnu.base">
20 | 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="cdt.managedbuild.target.gnu.platform.base.1613957877" name="Debug Platform" osList="linux,hpux,aix,qnx" superClass="cdt.managedbuild.target.gnu.platform.base"/>
21 | 							<builder id="cdt.managedbuild.target.gnu.builder.base.928301424" managedBuildOn="false" name="Gnu Make Builder.Default" superClass="cdt.managedbuild.target.gnu.builder.base"/>
22 | 							<tool id="cdt.managedbuild.tool.gnu.archiver.base.74538637" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
23 | 							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.base.1515344920" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.base"/>
24 | 							<tool id="cdt.managedbuild.tool.gnu.c.compiler.base.256501820" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.base"/>
25 | 							<tool id="cdt.managedbuild.tool.gnu.c.linker.base.244059677" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.base"/>
26 | 							<tool id="cdt.managedbuild.tool.gnu.cpp.linker.base.1621885740" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.base"/>
27 | 							<tool id="cdt.managedbuild.tool.gnu.assembler.base.2050561098" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.base"/>
28 | 						</toolChain>
29 | 					</folderInfo>
30 | 				</configuration>
31 | 			</storageModule>
32 | 			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
33 | 		</cconfiguration>
34 | 	</storageModule>
35 | 	<storageModule moduleId="scannerConfiguration">
36 | 		<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
37 | 	</storageModule>
38 | 	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
39 | 		<project id="bb3_event_ner.null.1920839198" name="bb3_event_ner"/>
40 | 	</storageModule>
41 | 	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
42 | </cproject>
43 | 


--------------------------------------------------------------------------------
/ade/ade.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * cdr.cpp
  3 |  *
  4 |  *  Created on: Dec 19, 2015
  5 |  *      Author: fox
  6 |  */
  7 | 
  8 | #include <vector>
  9 | #include "utils.h"
 10 | #include "FoxUtil.h"
 11 | #include <iostream>
 12 | #include "Token.h"
 13 | #include "SentSplitter.h"
 14 | #include "Tokenizer.h"
 15 | #include "N3L.h"
 16 | #include "Argument_helper.h"
 17 | #include "Options.h"
 18 | #include "Tool.h"
 19 | #include "BestPerformance.h"
 20 | 
 21 | 
 22 | #include "NNade3.h"
 23 | 
 24 | 
 25 | using namespace std;
 26 | 
 27 | 
 28 | int main(int argc, char **argv)
 29 | {
 30 | #if USE_CUDA==1
 31 |   InitTensorEngine();
 32 | #else
 33 |   InitTensorEngine<cpu>();
 34 | #endif
 35 | 
 36 | 
 37 | 	string optionFile;
 38 | 	string annotatedPath;
 39 | 	string processedPath;
 40 | 	string fold;
 41 | 
 42 | 
 43 | 
 44 | 	dsr::Argument_helper ah;
 45 | 	ah.new_named_string("annotated", "", "", "", annotatedPath);
 46 | 	ah.new_named_string("option", "", "", "", optionFile);
 47 | 	ah.new_named_string("processed", "", "", "", processedPath);
 48 | 	ah.new_named_string("fold", "", "", "", fold);
 49 | 
 50 | 
 51 | 
 52 | 	ah.process(argc, argv);
 53 | 	cout<<"annotated path: " <<annotatedPath <<endl;
 54 | 	cout<<"processed path: "<<processedPath<<endl;
 55 | 
 56 | 
 57 | 
 58 | 	Options options;
 59 | 	options.load(optionFile);
 60 | 
 61 | 	options.showOptions();
 62 | 
 63 | 	Tool tool(options);
 64 | 
 65 | 	vector< vector<fox::Sent> > processedGroups;
 66 | 	vector< vector<ADEsentence> > annotatedGroups;
 67 | 	loadAnnotatedFile(annotatedPath, annotatedGroups);
 68 | 	loadProcessedFile(processedPath, processedGroups);
 69 | 
 70 | 	if(!options.embFile.empty()) {
 71 | 		cout<< "load pre-trained emb"<<endl;
 72 | 		tool.w2v->loadFromBinFile(options.embFile, false, true);
 73 | 	}
 74 | 
 75 | 	vector<BestPerformance> bestAll;
 76 | 	int currentFold = atoi(fold.c_str());
 77 | 	for(int crossValid=0;crossValid<annotatedGroups.size();crossValid++) {
 78 | 		if(crossValid < currentFold ) {
 79 | 			continue;
 80 | 		}
 81 | /*		if(currentFold>=0 && crossValid!=currentFold) {
 82 | 			continue;
 83 | 		}*/
 84 | 		cout<<"###### group ###### "<<crossValid<<endl;
 85 | 
 86 | 		NNade3 nnade(options);
 87 | 
 88 | 
 89 | 		// crossValid as test, crossValid+1 as dev, other as train
 90 | 		vector<fox::Sent> processedTest;
 91 | 		vector<ADEsentence> annotatedTest;
 92 | 		vector<fox::Sent> processedDev;
 93 | 		vector<ADEsentence> annotatedDev;
 94 | 		vector<fox::Sent> processedTrain;
 95 | 		vector<ADEsentence> annotatedTrain;
 96 | 
 97 | 		for(int groupIdx=0;groupIdx<annotatedGroups.size();groupIdx++) {
 98 | 			if(groupIdx == crossValid) {
 99 | 				for(int sentIdx=0; sentIdx<annotatedGroups[groupIdx].size(); sentIdx++) {
100 | 					processedTest.push_back(processedGroups[groupIdx][sentIdx]);
101 | 					annotatedTest.push_back(annotatedGroups[groupIdx][sentIdx]);
102 | 				}
103 | 			} else if(groupIdx == (crossValid+1)%annotatedGroups.size()) {
104 | 				for(int sentIdx=0; sentIdx<annotatedGroups[groupIdx].size(); sentIdx++) {
105 | 					processedDev.push_back(processedGroups[groupIdx][sentIdx]);
106 | 					annotatedDev.push_back(annotatedGroups[groupIdx][sentIdx]);
107 | 				}
108 | 			} else {
109 | 				for(int sentIdx=0; sentIdx<annotatedGroups[groupIdx].size(); sentIdx++) {
110 | 					processedTrain.push_back(processedGroups[groupIdx][sentIdx]);
111 | 					annotatedTrain.push_back(annotatedGroups[groupIdx][sentIdx]);
112 | 				}
113 | 			}
114 | 
115 | 		}
116 | 
117 | 		BestPerformance best = nnade.trainAndTest(processedTest, annotatedTest, processedDev, annotatedDev, processedTrain, annotatedTrain, tool);
118 | 		bestAll.push_back(best);
119 | 	}
120 | 
121 | 	if(currentFold<0) {
122 | 		// marcro-average
123 | 		double pDev_Entity = 0;
124 | 		double rDev_Entity = 0;
125 | 		double f1Dev_Entity = 0;
126 | 		double pDev_Relation = 0;
127 | 		double rDev_Relation = 0;
128 | 		double f1Dev_Relation = 0;
129 | 		for(int i=0;i<bestAll.size();i++) {
130 | 			pDev_Entity += bestAll[i].dev_pEntity/bestAll.size();
131 | 			rDev_Entity += bestAll[i].dev_rEntity/bestAll.size();
132 | 			pDev_Relation += bestAll[i].dev_pRelation/bestAll.size();
133 | 			rDev_Relation += bestAll[i].dev_rRelation/bestAll.size();
134 | 		}
135 | 		f1Dev_Entity = f1(pDev_Entity, rDev_Entity);
136 | 		f1Dev_Relation = f1(pDev_Relation, rDev_Relation);
137 | 
138 | 		cout<<"### marcro-average ###"<<endl;
139 | 		cout<<"dev entity p "<<pDev_Entity<<endl;
140 | 		cout<<"dev entity r "<<rDev_Entity<<endl;
141 | 		cout<<"dev entity f1 "<<f1Dev_Entity<<endl;
142 | 		cout<<"dev relation p "<<pDev_Relation<<endl;
143 | 		cout<<"dev relation r "<<rDev_Relation<<endl;
144 | 		cout<<"dev relation f1 "<<f1Dev_Relation<<endl;
145 | 
146 | 
147 | 		double pTest_Entity = 0;
148 | 		double rTest_Entity = 0;
149 | 		double f1Test_Entity = 0;
150 | 		double pTest_Relation = 0;
151 | 		double rTest_Relation = 0;
152 | 		double f1Test_Relation = 0;
153 | 		for(int i=0;i<bestAll.size();i++) {
154 | 			pTest_Entity += bestAll[i].test_pEntity/bestAll.size();
155 | 			rTest_Entity += bestAll[i].test_rEntity/bestAll.size();
156 | 			pTest_Relation += bestAll[i].test_pRelation/bestAll.size();
157 | 			rTest_Relation += bestAll[i].test_rRelation/bestAll.size();
158 | 		}
159 | 		f1Test_Entity = f1(pTest_Entity, rTest_Entity);
160 | 		f1Test_Relation = f1(pTest_Relation, rTest_Relation);
161 | 
162 | 		cout<<"test entity p "<<pTest_Entity<<endl;
163 | 		cout<<"test entity r "<<rTest_Entity<<endl;
164 | 		cout<<"test entity f1 "<<f1Test_Entity<<endl;
165 | 		cout<<"test relation p "<<pTest_Relation<<endl;
166 | 		cout<<"test relation r "<<rTest_Relation<<endl;
167 | 		cout<<"test relation f1 "<<f1Test_Relation<<endl;
168 | 
169 | 	}
170 | 
171 | 
172 | 
173 | #if USE_CUDA==1
174 |   ShutdownTensorEngine();
175 | #else
176 |   ShutdownTensorEngine<cpu>();
177 | #endif
178 | 
179 |     return 0;
180 | 
181 | }
182 | 
183 | 


--------------------------------------------------------------------------------
/bb3/Options.h:
--------------------------------------------------------------------------------
  1 | #ifndef _PARSER_OPTIONS_
  2 | #define _PARSER_OPTIONS_
  3 | 
  4 | #pragma once
  5 | 
  6 | #include <string>
  7 | #include <fstream>
  8 | #include <vector>
  9 | #include <iostream>
 10 | #include "N3L.h"
 11 | 
 12 | using namespace std;
 13 | 
 14 | class Options {
 15 | public:
 16 | 
 17 |   int wordCutOff;
 18 | 
 19 |   dtype initRange;
 20 |   int maxIter;
 21 |   int batchSize;
 22 |   dtype adaEps;
 23 |   dtype adaAlpha;
 24 |   dtype regParameter;
 25 |   dtype dropProb;
 26 | 
 27 |   int evalPerIter;
 28 | 
 29 |   bool wordEmbFineTune;
 30 | 
 31 |   string abbrPath;
 32 |   string puncPath;
 33 | 
 34 |   int wordcontext;
 35 |   int wordEmbSize;
 36 |   int otherEmbSize;
 37 |   int hiddenSize;
 38 |   int rnnHiddenSize;
 39 | 
 40 |   int sent_window;
 41 | 
 42 |   int verboseIter;
 43 | 
 44 |   string output;
 45 |   string embFile;
 46 | 
 47 |   int beamSize1;
 48 |   int beamSize2;
 49 | 
 50 |   int poolType;
 51 | 
 52 |   Options() {
 53 |     wordCutOff = 0;
 54 |     initRange = 0.01;
 55 |     maxIter = 1000;
 56 |     batchSize = 1;
 57 |     adaEps = 1e-6;
 58 |     adaAlpha = 0.01;
 59 |     regParameter = 1e-8;
 60 |     dropProb = 0.5;
 61 | 
 62 |     wordcontext = 0;
 63 |     wordEmbSize = 50;
 64 |     otherEmbSize = 50;
 65 |     hiddenSize = 150;
 66 |     rnnHiddenSize = 100;
 67 | 
 68 |     evalPerIter = 1;
 69 |     wordEmbFineTune = true;
 70 | 
 71 |     abbrPath = "";
 72 |     puncPath = "";
 73 | 
 74 |     sent_window = 1;
 75 |     verboseIter = 0;
 76 | 
 77 |     output = "";
 78 |     embFile = "";
 79 | 
 80 |     beamSize1 = 1;
 81 |     beamSize2 = 1;
 82 | 
 83 |     poolType = 0;
 84 |   }
 85 | 
 86 |   Options(const Options& options) {
 87 | 	  wordCutOff = options.wordCutOff;
 88 | 	  initRange = options.initRange;
 89 | 	  maxIter = options.maxIter;
 90 | 	  batchSize = options.batchSize;
 91 | 	  adaEps = options.adaEps;
 92 | 	  adaAlpha = options.adaAlpha;
 93 | 	  regParameter = options.regParameter;
 94 | 	  dropProb = options.dropProb;
 95 | 
 96 | 	  wordcontext = options.wordcontext;
 97 | 	  wordEmbSize = options.wordEmbSize;
 98 | 	  otherEmbSize = options.otherEmbSize;
 99 | 		hiddenSize = options.hiddenSize;
100 | 		rnnHiddenSize = options.rnnHiddenSize;
101 | 
102 | 	  evalPerIter = options.evalPerIter;
103 | 	  wordEmbFineTune = options.wordEmbFineTune;
104 | 
105 | 		abbrPath = options.abbrPath;
106 | 		puncPath = options.puncPath;
107 | 
108 | 		sent_window  = options.sent_window;
109 | 
110 | 		verboseIter = options.verboseIter;
111 | 
112 | 		output = options.output;
113 | 		embFile = options.embFile;
114 | 
115 | 		beamSize1 = options.beamSize1;
116 | 		beamSize2 = options.beamSize2;
117 | 
118 | 		poolType = options.poolType;
119 |   }
120 | 
121 | /*  virtual ~Options() {
122 | 
123 |   }*/
124 | 
125 |   void setOptions(const vector<string> &vecOption) {
126 |     int i = 0;
127 |     for (; i < vecOption.size(); ++i) {
128 |       pair<string, string> pr;
129 |       string2pair(vecOption[i], pr, '=');
130 |       if (pr.first == "wordCutOff")
131 |         wordCutOff = atoi(pr.second.c_str());
132 |       else if (pr.first == "initRange")
133 |         initRange = atof(pr.second.c_str());
134 |       else if (pr.first == "maxIter")
135 |         maxIter = atoi(pr.second.c_str());
136 |       else if (pr.first == "batchSize")
137 |         batchSize = atoi(pr.second.c_str());
138 |       else if (pr.first == "adaEps")
139 |         adaEps = atof(pr.second.c_str());
140 |       else if (pr.first == "adaAlpha")
141 |         adaAlpha = atof(pr.second.c_str());
142 |       else if (pr.first == "regParameter")
143 |         regParameter = atof(pr.second.c_str());
144 |       else if (pr.first == "dropProb")
145 |         dropProb = atof(pr.second.c_str());
146 | 
147 |       else if (pr.first == "hiddenSize")
148 |         hiddenSize = atoi(pr.second.c_str());
149 |       else if (pr.first == "rnnHiddenSize")
150 |     	  rnnHiddenSize = atoi(pr.second.c_str());
151 | 
152 |       else if (pr.first == "wordcontext")
153 |     	  wordcontext = atoi(pr.second.c_str());
154 |       else if (pr.first == "wordEmbSize")
155 |         wordEmbSize = atoi(pr.second.c_str());
156 |       else if(pr.first == "otherEmbSize")
157 |     	  otherEmbSize = atoi(pr.second.c_str());
158 |         
159 | 
160 |       else if(pr.first == "evalPerIter")
161 |     	  evalPerIter = atoi(pr.second.c_str());
162 | 
163 |       else if (pr.first == "wordEmbFineTune")
164 |     	  wordEmbFineTune = (pr.second == "true") ? true : false;
165 | 
166 |       else if(pr.first == "abbrPath")
167 |     	  abbrPath = pr.second;
168 | 
169 |       else if(pr.first == "puncPath")
170 |     	  puncPath = pr.second;
171 |       else if (pr.first == "sent_window")
172 |     	  sent_window = atoi(pr.second.c_str());
173 |       else if(pr.first == "verboseIter")
174 |     	  verboseIter = atoi(pr.second.c_str());
175 | 
176 |       else if(pr.first == "output")
177 |           	  output = pr.second;
178 |       else if(pr.first == "embFile")
179 |           embFile = pr.second;
180 | 
181 |       else if(pr.first == "beamSize1")
182 |     	  beamSize1 = atoi(pr.second.c_str());
183 |       else if(pr.first == "beamSize2")
184 |     	  beamSize2 = atoi(pr.second.c_str());
185 | 
186 |       else if(pr.first == "poolType")
187 |     	  poolType = atoi(pr.second.c_str());
188 |     }
189 |   }
190 | 
191 |   void showOptions() {
192 |     std::cout << "wordCutOff = " << wordCutOff << std::endl;
193 |     std::cout << "initRange = " << initRange << std::endl;
194 |     std::cout << "maxIter = " << maxIter << std::endl;
195 |     std::cout << "batchSize = " << batchSize << std::endl;
196 |     std::cout << "adaEps = " << adaEps << std::endl;
197 |     std::cout << "adaAlpha = " << adaAlpha << std::endl;
198 |     std::cout << "regParameter = " << regParameter << std::endl;
199 |     std::cout << "dropProb = " << dropProb << std::endl;
200 | 
201 |     std::cout << "hiddenSize = " << hiddenSize << std::endl;
202 |     std::cout << "rnnHiddenSize = " << rnnHiddenSize << std::endl;
203 | 
204 |     std::cout<<"wordcontext = " << wordcontext << endl;
205 |     std::cout << "wordEmbSize = " << wordEmbSize << std::endl;
206 |     std::cout<<"otherEmbSize = "<<otherEmbSize << std::endl;
207 | 
208 |     cout<< "evalPerIter = " << evalPerIter << endl;
209 |     cout<< "wordEmbFineTune = "<<wordEmbFineTune<<endl;
210 | 
211 |     cout<<"abbrPath = "<<abbrPath<<endl;
212 |     cout<<"puncPath = "<<puncPath<<endl;
213 | 
214 |     cout<<"sent_window = "<<sent_window<<endl;
215 |     cout<<"verboseIter = "<<verboseIter<<endl;
216 |     cout<<"output = "<<output<<endl;
217 |     cout<<"embFile = "<<embFile<<endl;
218 | 
219 |     cout<<"beamSize1 = "<<beamSize1<<endl;
220 |     cout<<"beamSize2 = "<<beamSize2<<endl;
221 | 
222 |     cout<<"poolType = "<<poolType<<endl;
223 |   }
224 | 
225 |   void load(const std::string& infile) {
226 |     ifstream inf;
227 |     inf.open(infile.c_str());
228 |     vector<string> vecLine;
229 |     while (1) {
230 |       string strLine;
231 |       if (!my_getline(inf, strLine)) {
232 |         break;
233 |       }
234 |       if (strLine.empty())
235 |         continue;
236 |       vecLine.push_back(strLine);
237 |     }
238 |     inf.close();
239 |     setOptions(vecLine);
240 |   }
241 | };
242 | 
243 | #endif
244 | 
245 | 


--------------------------------------------------------------------------------
/ade/Options.h:
--------------------------------------------------------------------------------
  1 | #ifndef _PARSER_OPTIONS_
  2 | #define _PARSER_OPTIONS_
  3 | 
  4 | #pragma once
  5 | 
  6 | #include <string>
  7 | #include <fstream>
  8 | #include <vector>
  9 | #include <iostream>
 10 | #include "N3L.h"
 11 | 
 12 | using namespace std;
 13 | 
 14 | class Options {
 15 | public:
 16 | 
 17 |   int wordCutOff;
 18 | 
 19 |   dtype initRange;
 20 |   int maxIter;
 21 |   int batchSize;
 22 |   dtype adaEps;
 23 |   dtype adaAlpha;
 24 |   dtype regParameter;
 25 |   dtype dropProb;
 26 | 
 27 |   int evalPerIter;
 28 | 
 29 |   bool wordEmbFineTune;
 30 | 
 31 |   string abbrPath;
 32 |   string puncPath;
 33 | 
 34 |   int wordcontext;
 35 |   int wordEmbSize;
 36 |   int otherEmbSize;
 37 |   int hiddenSize;
 38 |   int rnnHiddenSize;
 39 | 
 40 |   int sent_window;
 41 | 
 42 |   int verboseIter;
 43 | 
 44 |   string output;
 45 |   string embFile;
 46 | 
 47 |   int beamSize1;
 48 |   int beamSize2;
 49 | 
 50 |   int poolType;
 51 | 
 52 | 
 53 |   Options() {
 54 |     wordCutOff = 0;
 55 |     initRange = 0.01;
 56 |     maxIter = 1000;
 57 |     batchSize = 1;
 58 |     adaEps = 1e-6;
 59 |     adaAlpha = 0.01;
 60 |     regParameter = 1e-8;
 61 |     dropProb = 0.5;
 62 | 
 63 |     wordcontext = 0;
 64 |     wordEmbSize = 50;
 65 |     otherEmbSize = 50;
 66 |     hiddenSize = 150;
 67 |     rnnHiddenSize = 100;
 68 | 
 69 |     evalPerIter = 1;
 70 |     wordEmbFineTune = true;
 71 | 
 72 |     abbrPath = "";
 73 |     puncPath = "";
 74 | 
 75 |     sent_window = 1;
 76 |     verboseIter = 0;
 77 | 
 78 |     output = "";
 79 |     embFile = "";
 80 | 
 81 |     beamSize1 = 1;
 82 |     beamSize2 = 1;
 83 | 
 84 |     poolType = 0;
 85 |   }
 86 | 
 87 |   Options(const Options& options) {
 88 | 	  wordCutOff = options.wordCutOff;
 89 | 	  initRange = options.initRange;
 90 | 	  maxIter = options.maxIter;
 91 | 	  batchSize = options.batchSize;
 92 | 	  adaEps = options.adaEps;
 93 | 	  adaAlpha = options.adaAlpha;
 94 | 	  regParameter = options.regParameter;
 95 | 	  dropProb = options.dropProb;
 96 | 
 97 | 	  wordcontext = options.wordcontext;
 98 | 	  wordEmbSize = options.wordEmbSize;
 99 | 	  otherEmbSize = options.otherEmbSize;
100 | 		hiddenSize = options.hiddenSize;
101 | 		rnnHiddenSize = options.rnnHiddenSize;
102 | 
103 | 	  evalPerIter = options.evalPerIter;
104 | 	  wordEmbFineTune = options.wordEmbFineTune;
105 | 
106 | 		abbrPath = options.abbrPath;
107 | 		puncPath = options.puncPath;
108 | 
109 | 		sent_window  = options.sent_window;
110 | 
111 | 		verboseIter = options.verboseIter;
112 | 
113 | 		output = options.output;
114 | 		embFile = options.embFile;
115 | 
116 | 		beamSize1 = options.beamSize1;
117 | 		beamSize2 = options.beamSize2;
118 | 
119 | 		poolType = options.poolType;
120 |   }
121 | 
122 | /*  virtual ~Options() {
123 | 
124 |   }*/
125 | 
126 |   void setOptions(const vector<string> &vecOption) {
127 |     int i = 0;
128 |     for (; i < vecOption.size(); ++i) {
129 |       pair<string, string> pr;
130 |       string2pair(vecOption[i], pr, '=');
131 |       if (pr.first == "wordCutOff")
132 |         wordCutOff = atoi(pr.second.c_str());
133 |       else if (pr.first == "initRange")
134 |         initRange = atof(pr.second.c_str());
135 |       else if (pr.first == "maxIter")
136 |         maxIter = atoi(pr.second.c_str());
137 |       else if (pr.first == "batchSize")
138 |         batchSize = atoi(pr.second.c_str());
139 |       else if (pr.first == "adaEps")
140 |         adaEps = atof(pr.second.c_str());
141 |       else if (pr.first == "adaAlpha")
142 |         adaAlpha = atof(pr.second.c_str());
143 |       else if (pr.first == "regParameter")
144 |         regParameter = atof(pr.second.c_str());
145 |       else if (pr.first == "dropProb")
146 |         dropProb = atof(pr.second.c_str());
147 | 
148 |       else if (pr.first == "hiddenSize")
149 |         hiddenSize = atoi(pr.second.c_str());
150 |       else if (pr.first == "rnnHiddenSize")
151 |     	  rnnHiddenSize = atoi(pr.second.c_str());
152 | 
153 |       else if (pr.first == "wordcontext")
154 |     	  wordcontext = atoi(pr.second.c_str());
155 |       else if (pr.first == "wordEmbSize")
156 |         wordEmbSize = atoi(pr.second.c_str());
157 |       else if(pr.first == "otherEmbSize")
158 |     	  otherEmbSize = atoi(pr.second.c_str());
159 |         
160 | 
161 |       else if(pr.first == "evalPerIter")
162 |     	  evalPerIter = atoi(pr.second.c_str());
163 | 
164 |       else if (pr.first == "wordEmbFineTune")
165 |     	  wordEmbFineTune = (pr.second == "true") ? true : false;
166 | 
167 |       else if(pr.first == "abbrPath")
168 |     	  abbrPath = pr.second;
169 | 
170 |       else if(pr.first == "puncPath")
171 |     	  puncPath = pr.second;
172 |       else if (pr.first == "sent_window")
173 |     	  sent_window = atoi(pr.second.c_str());
174 |       else if(pr.first == "verboseIter")
175 |     	  verboseIter = atoi(pr.second.c_str());
176 | 
177 |       else if(pr.first == "output")
178 |           	  output = pr.second;
179 |       else if(pr.first == "embFile")
180 |           embFile = pr.second;
181 | 
182 |       else if(pr.first == "beamSize1")
183 |     	  beamSize1 = atoi(pr.second.c_str());
184 |       else if(pr.first == "beamSize2")
185 |     	  beamSize2 = atoi(pr.second.c_str());
186 | 
187 |       else if(pr.first == "poolType")
188 |     	  poolType = atoi(pr.second.c_str());
189 |     }
190 |   }
191 | 
192 |   void showOptions() {
193 |     std::cout << "wordCutOff = " << wordCutOff << std::endl;
194 |     std::cout << "initRange = " << initRange << std::endl;
195 |     std::cout << "maxIter = " << maxIter << std::endl;
196 |     std::cout << "batchSize = " << batchSize << std::endl;
197 |     std::cout << "adaEps = " << adaEps << std::endl;
198 |     std::cout << "adaAlpha = " << adaAlpha << std::endl;
199 |     std::cout << "regParameter = " << regParameter << std::endl;
200 |     std::cout << "dropProb = " << dropProb << std::endl;
201 | 
202 |     std::cout << "hiddenSize = " << hiddenSize << std::endl;
203 |     std::cout << "rnnHiddenSize = " << rnnHiddenSize << std::endl;
204 | 
205 |     std::cout<<"wordcontext = " << wordcontext << endl;
206 |     std::cout << "wordEmbSize = " << wordEmbSize << std::endl;
207 |     std::cout<<"otherEmbSize = "<<otherEmbSize << std::endl;
208 | 
209 |     cout<< "evalPerIter = " << evalPerIter << endl;
210 |     cout<< "wordEmbFineTune = "<<wordEmbFineTune<<endl;
211 | 
212 |     cout<<"abbrPath = "<<abbrPath<<endl;
213 |     cout<<"puncPath = "<<puncPath<<endl;
214 | 
215 |     cout<<"sent_window = "<<sent_window<<endl;
216 |     cout<<"verboseIter = "<<verboseIter<<endl;
217 |     cout<<"output = "<<output<<endl;
218 |     cout<<"embFile = "<<embFile<<endl;
219 | 
220 |     cout<<"beamSize1 = "<<beamSize1<<endl;
221 |     cout<<"beamSize2 = "<<beamSize2<<endl;
222 | 
223 |     cout<<"poolType = "<<poolType<<endl;
224 |   }
225 | 
226 |   void load(const std::string& infile) {
227 |     ifstream inf;
228 |     inf.open(infile.c_str());
229 |     vector<string> vecLine;
230 |     while (1) {
231 |       string strLine;
232 |       if (!my_getline(inf, strLine)) {
233 |         break;
234 |       }
235 |       if (strLine.empty())
236 |         continue;
237 |       vecLine.push_back(strLine);
238 |     }
239 |     inf.close();
240 |     setOptions(vecLine);
241 |   }
242 | };
243 | 
244 | #endif
245 | 
246 | 


--------------------------------------------------------------------------------
/ade/CNN.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef CNN_H_
  3 | #define CNN_H_
  4 | 
  5 | // A standard convolutional neural network
  6 | 
  7 | #include "tensor.h"
  8 | #include "MyLib.h"
  9 | #include "Utiltensor.h"
 10 | #include "UniLayer.h"
 11 | #include "Attention_ZhouACL2016.h"
 12 | 
 13 | using namespace mshadow;
 14 | using namespace mshadow::expr;
 15 | using namespace mshadow::utils;
 16 | 
 17 | template<typename xpu>
 18 | class CNN {
 19 | public:
 20 |   UniLayer<xpu> _kernel;
 21 |   int _outputsize;
 22 |   int _inputsize;
 23 |   int _windowsize;
 24 |   int _kernelinputsize;
 25 |   int _poolType;
 26 | 
 27 |   Tensor<xpu, 2, dtype> _null, _nullLoss, _eg2null;
 28 | 
 29 |   AttentionZhouACL2016<xpu> _att;
 30 | 
 31 | public:
 32 |   CNN() {
 33 | 	  _outputsize = 0;
 34 | 	  _inputsize= 0;
 35 | 	  _windowsize= 0;
 36 | 	  _kernelinputsize= 0;
 37 | 	  _poolType = 0;
 38 |   }
 39 | 
 40 |   // outputsize is the dimension of this CNN
 41 |   // inputsize is the dimension of one element 'x' of the sequence
 42 |   // if windowsize is 1, the input of kernel will be x[i-1],x[i],x[i+1]
 43 |   // poolType: 0-max, 5-att
 44 |   inline void initial(int outputsize, int inputsize, int windowsize, int poolType=0, int funcType = 0, int seed = 0) {
 45 | 	  int kernelInputsize = inputsize + 2*windowsize*inputsize;
 46 | 
 47 | 	  _kernel.initial(outputsize, kernelInputsize, true, seed, funcType);
 48 | 
 49 |     _null = NewTensor<xpu>(Shape2(1, inputsize), d_zero);
 50 |     _nullLoss = NewTensor<xpu>(Shape2(1, inputsize), d_zero);
 51 |     _eg2null = NewTensor<xpu>(Shape2(1, inputsize), d_zero);
 52 | 
 53 |     _outputsize = outputsize;
 54 |     _inputsize = inputsize;
 55 |     _windowsize = windowsize;
 56 |     _kernelinputsize = kernelInputsize;
 57 |     _poolType = poolType;
 58 | 
 59 |     if(_poolType == 5) {
 60 |     	_att.initial(_outputsize, seed+13);
 61 |     }
 62 |   }
 63 | 
 64 |   inline void release() {
 65 | 	  _kernel.release();
 66 | 
 67 |     FreeSpace(&_null);
 68 |     FreeSpace(&_nullLoss);
 69 |     FreeSpace(&_eg2null);
 70 | 
 71 |     if(_poolType == 5) {
 72 |     	_att.release();
 73 |     }
 74 |   }
 75 | 
 76 |   inline void ComputeForwardScore(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y, Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs, Tensor<xpu, 3, dtype> poolIndex) {
 77 |     y = 0.0;
 78 |     int seq_size = x.size(0);
 79 |     if (seq_size == 0)
 80 |       return;
 81 | 
 82 |     	// convolution
 83 | 
 84 | 
 85 |       for (int idx = 0; idx < seq_size; idx++) {
 86 | 
 87 |     	  int windowBegin = idx-_windowsize;
 88 |     	  int windowEnd = idx+_windowsize;
 89 | 
 90 |     	  int kernelIdx = 0;
 91 |     	  for(int i=windowBegin;i<=windowEnd;i++) {
 92 |     		  if(i<0 || i>=seq_size) {
 93 |     			  for(int j=0;j<_inputsize;j++) {
 94 |     				  kernelInputs[idx][0][kernelIdx] = _null[0][j];
 95 |     				  kernelIdx++;
 96 |     			  }
 97 |     		  } else {
 98 |     			  for(int j=0;j<_inputsize;j++) {
 99 |     				  kernelInputs[idx][0][kernelIdx] = x[i][0][j];
100 |     				  kernelIdx++;
101 |     			  }
102 |     		  }
103 |     	  }
104 | 
105 |     	  _kernel.ComputeForwardScore(kernelInputs[idx], kernelOutputs[idx]);
106 | 
107 |       }
108 | 
109 |       maxpool_forward(kernelOutputs, y, poolIndex);
110 | 
111 |   }
112 | 
113 |   inline void ComputeBackwardLoss(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y,
114 | 		  Tensor<xpu, 2, dtype> ly, Tensor<xpu, 3, dtype> lx,
115 | 		  Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs,
116 | 		  Tensor<xpu, 3, dtype> poolIndex, bool bclear = false) {
117 |     int seq_size = x.size(0);
118 |     if (seq_size == 0)
119 |       return;
120 | 
121 |     if (bclear)
122 |       lx = 0.0;
123 | 
124 |     Tensor<xpu, 3, dtype> l_kernelOutputs= NewTensor<xpu>(Shape3(seq_size, 1, _outputsize), d_zero);
125 |     pool_backward(ly, poolIndex, l_kernelOutputs);
126 | 
127 |     Tensor<xpu, 3, dtype> l_kernelInputs = NewTensor<xpu>(Shape3(seq_size, 1, _kernelinputsize), d_zero);
128 |     for (int idx = 0; idx < seq_size; idx++) {
129 | 
130 |     	_kernel.ComputeBackwardLoss(kernelInputs[idx], kernelOutputs[idx], l_kernelOutputs[idx], l_kernelInputs[idx]);
131 | 
132 |   	  int windowBegin = idx-_windowsize;
133 |   	  int windowEnd = idx+_windowsize;
134 | 
135 |   	  int kernelIdx = 0;
136 |   	  for(int i=windowBegin;i<=windowEnd;i++) {
137 |   		  if(i<0 || i>=seq_size) {
138 |   			  for(int j=0;j<_inputsize;j++) {
139 |   				  _nullLoss[0][j] += l_kernelInputs[idx][0][kernelIdx];
140 |   				  kernelIdx++;
141 |   			  }
142 |   		  } else {
143 |   			  for(int j=0;j<_inputsize;j++) {
144 |   				  lx[i][0][j] += l_kernelInputs[idx][0][kernelIdx];
145 |   				  kernelIdx++;
146 |   			  }
147 |   		  }
148 |   	  }
149 | 
150 | 
151 | 
152 |     }
153 | 
154 |     FreeSpace(&l_kernelOutputs);
155 |     FreeSpace(&l_kernelInputs);
156 | 
157 |   }
158 | 
159 |   // if attention, use this one
160 |   inline void ComputeForwardScore(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y,
161 | 		  Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs,
162 | 		  Tensor<xpu, 3, dtype> poolIndex,
163 | 		  Tensor<xpu, 3, dtype> M,
164 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
165 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r
166 | 		  ) {
167 |     y = 0.0;
168 |     int seq_size = x.size(0);
169 |     if (seq_size == 0)
170 |       return;
171 | 
172 |     	// convolution
173 | 
174 | 
175 |       for (int idx = 0; idx < seq_size; idx++) {
176 | 
177 |     	  int windowBegin = idx-_windowsize;
178 |     	  int windowEnd = idx+_windowsize;
179 | 
180 |     	  int kernelIdx = 0;
181 |     	  for(int i=windowBegin;i<=windowEnd;i++) {
182 |     		  if(i<0 || i>=seq_size) {
183 |     			  for(int j=0;j<_inputsize;j++) {
184 |     				  kernelInputs[idx][0][kernelIdx] = _null[0][j];
185 |     				  kernelIdx++;
186 |     			  }
187 |     		  } else {
188 |     			  for(int j=0;j<_inputsize;j++) {
189 |     				  kernelInputs[idx][0][kernelIdx] = x[i][0][j];
190 |     				  kernelIdx++;
191 |     			  }
192 |     		  }
193 |     	  }
194 | 
195 |     	  _kernel.ComputeForwardScore(kernelInputs[idx], kernelOutputs[idx]);
196 | 
197 |       }
198 | 
199 |       _att.ComputeForwardScore(kernelOutputs, M, omegaM, exp_omegaM, alpha, r, y);
200 | 
201 |   }
202 | 
203 |   inline void ComputeBackwardLoss(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y,
204 | 		  Tensor<xpu, 2, dtype> ly, Tensor<xpu, 3, dtype> lx,
205 | 		  Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs,
206 | 		  Tensor<xpu, 3, dtype> poolIndex,
207 | 		  Tensor<xpu, 3, dtype> M, Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
208 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
209 | 		  bool bclear = false) {
210 |     int seq_size = x.size(0);
211 |     if (seq_size == 0)
212 |       return;
213 | 
214 |     if (bclear)
215 |       lx = 0.0;
216 | 
217 |     Tensor<xpu, 3, dtype> l_kernelOutputs= NewTensor<xpu>(Shape3(seq_size, 1, _outputsize), d_zero);
218 |     _att.ComputeBackwardLoss(kernelOutputs, M, omegaM, exp_omegaM, alpha, r,
219 |     		  y, ly, l_kernelOutputs);
220 | 
221 |     Tensor<xpu, 3, dtype> l_kernelInputs = NewTensor<xpu>(Shape3(seq_size, 1, _kernelinputsize), d_zero);
222 |     for (int idx = 0; idx < seq_size; idx++) {
223 | 
224 |     	_kernel.ComputeBackwardLoss(kernelInputs[idx], kernelOutputs[idx], l_kernelOutputs[idx], l_kernelInputs[idx]);
225 | 
226 |   	  int windowBegin = idx-_windowsize;
227 |   	  int windowEnd = idx+_windowsize;
228 | 
229 |   	  int kernelIdx = 0;
230 |   	  for(int i=windowBegin;i<=windowEnd;i++) {
231 |   		  if(i<0 || i>=seq_size) {
232 |   			  for(int j=0;j<_inputsize;j++) {
233 |   				  _nullLoss[0][j] += l_kernelInputs[idx][0][kernelIdx];
234 |   				  kernelIdx++;
235 |   			  }
236 |   		  } else {
237 |   			  for(int j=0;j<_inputsize;j++) {
238 |   				  lx[i][0][j] += l_kernelInputs[idx][0][kernelIdx];
239 |   				  kernelIdx++;
240 |   			  }
241 |   		  }
242 |   	  }
243 | 
244 | 
245 | 
246 |     }
247 | 
248 |     FreeSpace(&l_kernelOutputs);
249 |     FreeSpace(&l_kernelInputs);
250 | 
251 |   }
252 | 
253 |   inline void updateAdaGrad(dtype regularizationWeight, dtype adaAlpha, dtype adaEps) {
254 | 	  _nullLoss = _nullLoss + _null * regularizationWeight;
255 |     _eg2null = _eg2null + _nullLoss * _nullLoss;
256 |     _null = _null - _nullLoss * adaAlpha / F<nl_sqrt>(_eg2null + adaEps);
257 | 
258 |     _kernel.updateAdaGrad(regularizationWeight, adaAlpha, adaEps);
259 | 
260 |     if(_poolType == 5) {
261 |     	_att.updateAdaGrad(regularizationWeight, adaAlpha, adaEps);
262 |     }
263 | 
264 |     clearGrad();
265 |   }
266 | 
267 |   inline void clearGrad() {
268 |     _nullLoss = 0;
269 |   }
270 | 
271 | };
272 | 
273 | #endif /* CNN_H_ */
274 | 


--------------------------------------------------------------------------------
/bb3/CNN.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef CNN_H_
  3 | #define CNN_H_
  4 | 
  5 | // A standard convolutional neural network
  6 | 
  7 | #include "tensor.h"
  8 | #include "MyLib.h"
  9 | #include "Utiltensor.h"
 10 | #include "UniLayer.h"
 11 | #include "Attention_ZhouACL2016.h"
 12 | 
 13 | using namespace mshadow;
 14 | using namespace mshadow::expr;
 15 | using namespace mshadow::utils;
 16 | 
 17 | template<typename xpu>
 18 | class CNN {
 19 | public:
 20 |   UniLayer<xpu> _kernel;
 21 |   int _outputsize;
 22 |   int _inputsize;
 23 |   int _windowsize;
 24 |   int _kernelinputsize;
 25 |   int _poolType;
 26 | 
 27 |   Tensor<xpu, 2, dtype> _null, _nullLoss, _eg2null;
 28 | 
 29 |   AttentionZhouACL2016<xpu> _att;
 30 | 
 31 | public:
 32 |   CNN() {
 33 | 	  _outputsize = 0;
 34 | 	  _inputsize= 0;
 35 | 	  _windowsize= 0;
 36 | 	  _kernelinputsize= 0;
 37 | 	  _poolType = 0;
 38 |   }
 39 | 
 40 |   // outputsize is the dimension of this CNN
 41 |   // inputsize is the dimension of one element 'x' of the sequence
 42 |   // if windowsize is 1, the input of kernel will be x[i-1],x[i],x[i+1]
 43 |   // poolType: 0-max, 5-att
 44 |   inline void initial(int outputsize, int inputsize, int windowsize, int poolType=0, int funcType = 0, int seed = 0) {
 45 | 	  int kernelInputsize = inputsize + 2*windowsize*inputsize;
 46 | 
 47 | 	  _kernel.initial(outputsize, kernelInputsize, true, seed, funcType);
 48 | 
 49 |     _null = NewTensor<xpu>(Shape2(1, inputsize), d_zero);
 50 |     _nullLoss = NewTensor<xpu>(Shape2(1, inputsize), d_zero);
 51 |     _eg2null = NewTensor<xpu>(Shape2(1, inputsize), d_zero);
 52 | 
 53 |     _outputsize = outputsize;
 54 |     _inputsize = inputsize;
 55 |     _windowsize = windowsize;
 56 |     _kernelinputsize = kernelInputsize;
 57 |     _poolType = poolType;
 58 | 
 59 |     if(_poolType == 5) {
 60 |     	_att.initial(_outputsize, seed+13);
 61 |     }
 62 |   }
 63 | 
 64 |   inline void release() {
 65 | 	  _kernel.release();
 66 | 
 67 |     FreeSpace(&_null);
 68 |     FreeSpace(&_nullLoss);
 69 |     FreeSpace(&_eg2null);
 70 | 
 71 |     if(_poolType == 5) {
 72 |     	_att.release();
 73 |     }
 74 |   }
 75 | 
 76 |   inline void ComputeForwardScore(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y, Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs, Tensor<xpu, 3, dtype> poolIndex) {
 77 |     y = 0.0;
 78 |     int seq_size = x.size(0);
 79 |     if (seq_size == 0)
 80 |       return;
 81 | 
 82 |     	// convolution
 83 | 
 84 | 
 85 |       for (int idx = 0; idx < seq_size; idx++) {
 86 | 
 87 |     	  int windowBegin = idx-_windowsize;
 88 |     	  int windowEnd = idx+_windowsize;
 89 | 
 90 |     	  int kernelIdx = 0;
 91 |     	  for(int i=windowBegin;i<=windowEnd;i++) {
 92 |     		  if(i<0 || i>=seq_size) {
 93 |     			  for(int j=0;j<_inputsize;j++) {
 94 |     				  kernelInputs[idx][0][kernelIdx] = _null[0][j];
 95 |     				  kernelIdx++;
 96 |     			  }
 97 |     		  } else {
 98 |     			  for(int j=0;j<_inputsize;j++) {
 99 |     				  kernelInputs[idx][0][kernelIdx] = x[i][0][j];
100 |     				  kernelIdx++;
101 |     			  }
102 |     		  }
103 |     	  }
104 | 
105 |     	  _kernel.ComputeForwardScore(kernelInputs[idx], kernelOutputs[idx]);
106 | 
107 |       }
108 | 
109 |       maxpool_forward(kernelOutputs, y, poolIndex);
110 | 
111 |   }
112 | 
113 |   inline void ComputeBackwardLoss(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y,
114 | 		  Tensor<xpu, 2, dtype> ly, Tensor<xpu, 3, dtype> lx,
115 | 		  Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs,
116 | 		  Tensor<xpu, 3, dtype> poolIndex, bool bclear = false) {
117 |     int seq_size = x.size(0);
118 |     if (seq_size == 0)
119 |       return;
120 | 
121 |     if (bclear)
122 |       lx = 0.0;
123 | 
124 |     Tensor<xpu, 3, dtype> l_kernelOutputs= NewTensor<xpu>(Shape3(seq_size, 1, _outputsize), d_zero);
125 |     pool_backward(ly, poolIndex, l_kernelOutputs);
126 | 
127 |     Tensor<xpu, 3, dtype> l_kernelInputs = NewTensor<xpu>(Shape3(seq_size, 1, _kernelinputsize), d_zero);
128 |     for (int idx = 0; idx < seq_size; idx++) {
129 | 
130 |     	_kernel.ComputeBackwardLoss(kernelInputs[idx], kernelOutputs[idx], l_kernelOutputs[idx], l_kernelInputs[idx]);
131 | 
132 |   	  int windowBegin = idx-_windowsize;
133 |   	  int windowEnd = idx+_windowsize;
134 | 
135 |   	  int kernelIdx = 0;
136 |   	  for(int i=windowBegin;i<=windowEnd;i++) {
137 |   		  if(i<0 || i>=seq_size) {
138 |   			  for(int j=0;j<_inputsize;j++) {
139 |   				  _nullLoss[0][j] += l_kernelInputs[idx][0][kernelIdx];
140 |   				  kernelIdx++;
141 |   			  }
142 |   		  } else {
143 |   			  for(int j=0;j<_inputsize;j++) {
144 |   				  lx[i][0][j] += l_kernelInputs[idx][0][kernelIdx];
145 |   				  kernelIdx++;
146 |   			  }
147 |   		  }
148 |   	  }
149 | 
150 | 
151 | 
152 |     }
153 | 
154 |     FreeSpace(&l_kernelOutputs);
155 |     FreeSpace(&l_kernelInputs);
156 | 
157 |   }
158 | 
159 |   // if attention, use this one
160 |   inline void ComputeForwardScore(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y,
161 | 		  Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs,
162 | 		  Tensor<xpu, 3, dtype> poolIndex,
163 | 		  Tensor<xpu, 3, dtype> M,
164 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
165 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r
166 | 		  ) {
167 |     y = 0.0;
168 |     int seq_size = x.size(0);
169 |     if (seq_size == 0)
170 |       return;
171 | 
172 |     	// convolution
173 | 
174 | 
175 |       for (int idx = 0; idx < seq_size; idx++) {
176 | 
177 |     	  int windowBegin = idx-_windowsize;
178 |     	  int windowEnd = idx+_windowsize;
179 | 
180 |     	  int kernelIdx = 0;
181 |     	  for(int i=windowBegin;i<=windowEnd;i++) {
182 |     		  if(i<0 || i>=seq_size) {
183 |     			  for(int j=0;j<_inputsize;j++) {
184 |     				  kernelInputs[idx][0][kernelIdx] = _null[0][j];
185 |     				  kernelIdx++;
186 |     			  }
187 |     		  } else {
188 |     			  for(int j=0;j<_inputsize;j++) {
189 |     				  kernelInputs[idx][0][kernelIdx] = x[i][0][j];
190 |     				  kernelIdx++;
191 |     			  }
192 |     		  }
193 |     	  }
194 | 
195 |     	  _kernel.ComputeForwardScore(kernelInputs[idx], kernelOutputs[idx]);
196 | 
197 |       }
198 | 
199 |       _att.ComputeForwardScore(kernelOutputs, M, omegaM, exp_omegaM, alpha, r, y);
200 | 
201 |   }
202 | 
203 |   inline void ComputeBackwardLoss(Tensor<xpu, 3, dtype> x, Tensor<xpu, 2, dtype> y,
204 | 		  Tensor<xpu, 2, dtype> ly, Tensor<xpu, 3, dtype> lx,
205 | 		  Tensor<xpu, 3, dtype> kernelInputs, Tensor<xpu, 3, dtype> kernelOutputs,
206 | 		  Tensor<xpu, 3, dtype> poolIndex,
207 | 		  Tensor<xpu, 3, dtype> M, Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
208 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
209 | 		  bool bclear = false) {
210 |     int seq_size = x.size(0);
211 |     if (seq_size == 0)
212 |       return;
213 | 
214 |     if (bclear)
215 |       lx = 0.0;
216 | 
217 |     Tensor<xpu, 3, dtype> l_kernelOutputs= NewTensor<xpu>(Shape3(seq_size, 1, _outputsize), d_zero);
218 |     _att.ComputeBackwardLoss(kernelOutputs, M, omegaM, exp_omegaM, alpha, r,
219 |     		  y, ly, l_kernelOutputs);
220 | 
221 |     Tensor<xpu, 3, dtype> l_kernelInputs = NewTensor<xpu>(Shape3(seq_size, 1, _kernelinputsize), d_zero);
222 |     for (int idx = 0; idx < seq_size; idx++) {
223 | 
224 |     	_kernel.ComputeBackwardLoss(kernelInputs[idx], kernelOutputs[idx], l_kernelOutputs[idx], l_kernelInputs[idx]);
225 | 
226 |   	  int windowBegin = idx-_windowsize;
227 |   	  int windowEnd = idx+_windowsize;
228 | 
229 |   	  int kernelIdx = 0;
230 |   	  for(int i=windowBegin;i<=windowEnd;i++) {
231 |   		  if(i<0 || i>=seq_size) {
232 |   			  for(int j=0;j<_inputsize;j++) {
233 |   				  _nullLoss[0][j] += l_kernelInputs[idx][0][kernelIdx];
234 |   				  kernelIdx++;
235 |   			  }
236 |   		  } else {
237 |   			  for(int j=0;j<_inputsize;j++) {
238 |   				  lx[i][0][j] += l_kernelInputs[idx][0][kernelIdx];
239 |   				  kernelIdx++;
240 |   			  }
241 |   		  }
242 |   	  }
243 | 
244 | 
245 | 
246 |     }
247 | 
248 |     FreeSpace(&l_kernelOutputs);
249 |     FreeSpace(&l_kernelInputs);
250 | 
251 |   }
252 | 
253 |   inline void updateAdaGrad(dtype regularizationWeight, dtype adaAlpha, dtype adaEps) {
254 | 	  _nullLoss = _nullLoss + _null * regularizationWeight;
255 |     _eg2null = _eg2null + _nullLoss * _nullLoss;
256 |     _null = _null - _nullLoss * adaAlpha / F<nl_sqrt>(_eg2null + adaEps);
257 | 
258 |     _kernel.updateAdaGrad(regularizationWeight, adaAlpha, adaEps);
259 | 
260 |     if(_poolType == 5) {
261 |     	_att.updateAdaGrad(regularizationWeight, adaAlpha, adaEps);
262 |     }
263 | 
264 |     clearGrad();
265 |   }
266 | 
267 |   inline void clearGrad() {
268 |     _nullLoss = 0;
269 |   }
270 | 
271 | };
272 | 
273 | #endif /* CNN_H_ */
274 | 


--------------------------------------------------------------------------------
/ade/Attention_ZhouACL2016.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef SRC_AttentionZhouACL2016_H_
  3 | #define SRC_AttentionZhouACL2016_H_
  4 | #include "tensor.h"
  5 | 
  6 | #include "BiLayer.h"
  7 | #include "MyLib.h"
  8 | #include "Utiltensor.h"
  9 | #include "Pooling.h"
 10 | #include "UniLayer.h"
 11 | 
 12 | using namespace mshadow;
 13 | using namespace mshadow::expr;
 14 | using namespace mshadow::utils;
 15 | 
 16 | // This is re-implementment of the work of Zhou et al. (2016) in ACL.
 17 | // Attention-Based Bidirectional LSTM Networks for Relation Classification
 18 | 
 19 | template<typename xpu>
 20 | class AttentionZhouACL2016 {
 21 | 
 22 | public:
 23 | 	Tensor<xpu, 2, dtype> _omega;
 24 | 	Tensor<xpu, 2, dtype> _gradOmega;
 25 | 	Tensor<xpu, 2, dtype> _eg2Omega;
 26 | 
 27 | 	int _dw = 0;
 28 | 
 29 | 
 30 |   AttentionZhouACL2016() {
 31 |   }
 32 | 
 33 |   inline void initial(int inputAndOutputSize, int seed = 0) {
 34 | 	  _dw = inputAndOutputSize;
 35 | 
 36 | 
 37 | 	dtype bound = sqrt(6.0 / (_dw + 1));
 38 | 
 39 | 	_omega = NewTensor<xpu>(Shape2(1, _dw), d_zero);
 40 | 	_gradOmega = NewTensor<xpu>(Shape2(1, _dw), d_zero);
 41 | 	_eg2Omega = NewTensor<xpu>(Shape2(1, _dw), d_zero);
 42 | 
 43 | 
 44 | 	random(_omega, -1.0 * bound, 1.0 * bound, seed);
 45 |   }
 46 | 
 47 | 
 48 |   inline void release() {
 49 | 	    FreeSpace(&_omega);
 50 | 	    FreeSpace(&_gradOmega);
 51 | 	    FreeSpace(&_eg2Omega);
 52 |   }
 53 | 
 54 | 
 55 | public:
 56 | 
 57 |   // assume that all the vector is row vector, so the formulas should be adjusted.
 58 |   inline void ComputeForwardScore(std::vector<Tensor<xpu, 2, dtype> >& H, std::vector<Tensor<xpu, 2, dtype> >& M,
 59 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
 60 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
 61 | 		  Tensor<xpu, 2, dtype> hStar) {
 62 | 
 63 |     int seq_size = H.size();
 64 |     if(seq_size == 0) return;
 65 | 
 66 | 
 67 | 
 68 |     for(int i=0;i<seq_size;i++) {
 69 |     	M[i] = F<nl_tanh>(H[i]); // M = tanh(H)
 70 |     	for(int j=0;j<_dw;j++)
 71 |     		omegaM[0][i] += _omega[0][j]*M[i][0][j]; // dot(_omega, M[i].T()); // t(w)*M
 72 |     }
 73 | 
 74 |     // alpha = softmax(t(w)*M)
 75 | /*    int optLabel = -1;
 76 |     for (int i = 0; i < seq_size; ++i) {
 77 |         if (optLabel < 0 || omegaM[0][i] > omegaM[0][optLabel])
 78 |           optLabel = i;
 79 |     }*/
 80 |     dtype sum = 0;
 81 |     //dtype maxScore = omegaM[0][optLabel];
 82 |     for (int i = 0; i < seq_size; ++i) {
 83 |     	exp_omegaM[0][i] = exp(omegaM[0][i] /*- maxScore*/);
 84 |     	sum += exp_omegaM[0][i];
 85 |     }
 86 |     for (int i = 0; i < seq_size; ++i) {
 87 |     	alpha[0][i] = exp_omegaM[0][i]/sum;
 88 |     }
 89 | 
 90 |     // r = H*t(alpha)
 91 |     for(int i = 0; i < _dw; ++i) {
 92 |     	for(int j=0; j<seq_size; j++) {
 93 |     		r[0][i] += H[j][0][i]*alpha[0][j];
 94 |     	}
 95 |     }
 96 | 
 97 |     // h* = tanh(r)
 98 |     hStar = F<nl_tanh>(r);
 99 | 
100 | /*    for(int i = 0; i < _dw; ++i) {
101 |     	for(int j=0;j<seq_size;j++)
102 |     		hStar[0][i] += H[j][0][i];
103 |     }*/
104 | 
105 |   }
106 | 
107 | 
108 | 
109 |   inline void ComputeBackwardLoss(std::vector<Tensor<xpu, 2, dtype> >& H, std::vector<Tensor<xpu, 2, dtype> >& M,
110 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
111 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
112 | 		  Tensor<xpu, 2, dtype> hStar, Tensor<xpu, 2, dtype> lhStar,
113 | 		  std::vector<Tensor<xpu, 2, dtype> >& lH, bool bclear = false) {
114 | 
115 | 	  int seq_size = H.size();
116 | 	  if(seq_size == 0) return;
117 | 
118 |     if(bclear){
119 |       for (int idx = 0; idx < seq_size; idx++) {
120 |     	  lH[idx] = 0.0;
121 |       }
122 |     }
123 | 
124 | 
125 | 
126 |     Tensor<xpu, 2, dtype> lr = NewTensor<xpu>(Shape2(r.size(0), r.size(1)), d_zero);
127 |     lr += lhStar * F<nl_dtanh>(hStar);
128 | 
129 |     Tensor<xpu, 2, dtype> lalpha = NewTensor<xpu>(Shape2(alpha.size(0), alpha.size(1)), d_zero);
130 |     for(int i = 0; i < _dw; ++i) {
131 |     	for(int j=0; j<seq_size; j++) {
132 |     		lH[j][0][i] += lr[0][i] * alpha[0][j];
133 |     		lalpha[0][j] += lr[0][i] * H[j][0][i];
134 |     	}
135 |     }
136 | 
137 |     Tensor<xpu, 2, dtype> lOmegaM = NewTensor<xpu>(Shape2(omegaM.size(0), omegaM.size(1)), d_zero);
138 |     for (int i = 0; i < seq_size; ++i) {
139 |     	for(int j=0;j<seq_size;j++) {
140 |     		if(j==i)
141 |     			lOmegaM[0][i] += lalpha[0][j] * alpha[0][j] * (1-alpha[0][j]);
142 |     		else
143 |     			lOmegaM[0][i] += lalpha[0][j] * (-alpha[0][j]*alpha[0][i]);
144 |     	}
145 |     }
146 | 
147 |     std::vector<Tensor<xpu, 2, dtype> > lM(seq_size);
148 |     for (int idx = 0; idx < seq_size; idx++) {
149 |       lM[idx] = NewTensor<xpu>(Shape2(M[idx].size(0), M[idx].size(1)), d_zero);
150 |     }
151 |     for(int i=0;i<seq_size;i++) {
152 | 		_gradOmega += lOmegaM[0][i] * M[i];
153 | 		lM[i] += lOmegaM[0][i] * _omega;
154 | 		lH[i] += lM[i] * F<nl_dtanh>(M[i]);
155 | 	}
156 | 
157 | 
158 |     FreeSpace(&lr);
159 |     FreeSpace(&lalpha);
160 |     FreeSpace(&lOmegaM);
161 |     for (int idx = 0; idx < seq_size; idx++) {
162 |       FreeSpace(&(lM[idx]));
163 |     }
164 | 
165 | /*    for(int i = 0; i < _dw; ++i) {
166 |     	for(int j=0;j<seq_size;j++)
167 |     		lH[j][0][i] += lhStar[0][i];
168 |     }*/
169 | 
170 | 
171 | 
172 |   }
173 | 
174 | 
175 |   inline void ComputeForwardScore(Tensor<xpu, 3, dtype>  H, Tensor<xpu, 3, dtype>  M,
176 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
177 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
178 | 		  Tensor<xpu, 2, dtype> hStar) {
179 | 
180 |     int seq_size = H.size(0);
181 |     if(seq_size == 0) return;
182 | 
183 | 
184 | 
185 |     for(int i=0;i<seq_size;i++) {
186 |     	M[i] = F<nl_tanh>(H[i]); // M = tanh(H)
187 |     	for(int j=0;j<_dw;j++)
188 |     		omegaM[0][i] += _omega[0][j]*M[i][0][j]; // dot(_omega, M[i].T()); // t(w)*M
189 |     }
190 | 
191 |     // alpha = softmax(t(w)*M)
192 |     dtype sum = 0;
193 |     for (int i = 0; i < seq_size; ++i) {
194 |     	exp_omegaM[0][i] = exp(omegaM[0][i] );
195 |     	sum += exp_omegaM[0][i];
196 |     }
197 |     for (int i = 0; i < seq_size; ++i) {
198 |     	alpha[0][i] = exp_omegaM[0][i]/sum;
199 |     }
200 | 
201 |     // r = H*t(alpha)
202 |     for(int i = 0; i < _dw; ++i) {
203 |     	for(int j=0; j<seq_size; j++) {
204 |     		r[0][i] += H[j][0][i]*alpha[0][j];
205 |     	}
206 |     }
207 | 
208 |     // h* = tanh(r)
209 |     hStar = F<nl_tanh>(r);
210 | 
211 | 
212 |   }
213 | 
214 | 
215 | 
216 |   inline void ComputeBackwardLoss(Tensor<xpu, 3, dtype> H, Tensor<xpu, 3, dtype> M,
217 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
218 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
219 | 		  Tensor<xpu, 2, dtype> hStar, Tensor<xpu, 2, dtype> lhStar,
220 | 		  Tensor<xpu, 3, dtype> lH, bool bclear = false) {
221 | 
222 | 	  int seq_size = H.size(0);
223 | 	  if(seq_size == 0) return;
224 | 
225 |     if(bclear){
226 |       for (int idx = 0; idx < seq_size; idx++) {
227 |     	  lH[idx] = 0.0;
228 |       }
229 |     }
230 | 
231 | 
232 | 
233 |     Tensor<xpu, 2, dtype> lr = NewTensor<xpu>(Shape2(r.size(0), r.size(1)), d_zero);
234 |     lr += lhStar * F<nl_dtanh>(hStar);
235 | 
236 |     Tensor<xpu, 2, dtype> lalpha = NewTensor<xpu>(Shape2(alpha.size(0), alpha.size(1)), d_zero);
237 |     for(int i = 0; i < _dw; ++i) {
238 |     	for(int j=0; j<seq_size; j++) {
239 |     		lH[j][0][i] += lr[0][i] * alpha[0][j];
240 |     		lalpha[0][j] += lr[0][i] * H[j][0][i];
241 |     	}
242 |     }
243 | 
244 |     Tensor<xpu, 2, dtype> lOmegaM = NewTensor<xpu>(Shape2(omegaM.size(0), omegaM.size(1)), d_zero);
245 |     for (int i = 0; i < seq_size; ++i) {
246 |     	for(int j=0;j<seq_size;j++) {
247 |     		if(j==i)
248 |     			lOmegaM[0][i] += lalpha[0][j] * alpha[0][j] * (1-alpha[0][j]);
249 |     		else
250 |     			lOmegaM[0][i] += lalpha[0][j] * (-alpha[0][j]*alpha[0][i]);
251 |     	}
252 |     }
253 | 
254 |     std::vector<Tensor<xpu, 2, dtype> > lM(seq_size);
255 |     for (int idx = 0; idx < seq_size; idx++) {
256 |       lM[idx] = NewTensor<xpu>(Shape2(M[idx].size(0), M[idx].size(1)), d_zero);
257 |     }
258 |     for(int i=0;i<seq_size;i++) {
259 | 		_gradOmega += lOmegaM[0][i] * M[i];
260 | 		lM[i] += lOmegaM[0][i] * _omega;
261 | 		lH[i] += lM[i] * F<nl_dtanh>(M[i]);
262 | 	}
263 | 
264 | 
265 |     FreeSpace(&lr);
266 |     FreeSpace(&lalpha);
267 |     FreeSpace(&lOmegaM);
268 |     for (int idx = 0; idx < seq_size; idx++) {
269 |       FreeSpace(&(lM[idx]));
270 |     }
271 | 
272 | 
273 |   }
274 | 
275 | 
276 | 
277 |   inline void updateAdaGrad(dtype regularizationWeight, dtype adaAlpha, dtype adaEps) {
278 |     _gradOmega = _gradOmega + _omega * regularizationWeight;
279 |     _eg2Omega= _eg2Omega + _gradOmega * _gradOmega;
280 |     _omega = _omega - _gradOmega * adaAlpha / F<nl_sqrt>(_eg2Omega + adaEps);
281 | 
282 |     clearGrad();
283 |   }
284 | 
285 |   inline void clearGrad() {
286 |     _gradOmega = 0;
287 |   }
288 | 
289 | 
290 | };
291 | 
292 | #endif
293 | 


--------------------------------------------------------------------------------
/bb3/Attention_ZhouACL2016.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef SRC_AttentionZhouACL2016_H_
  3 | #define SRC_AttentionZhouACL2016_H_
  4 | #include "tensor.h"
  5 | 
  6 | #include "BiLayer.h"
  7 | #include "MyLib.h"
  8 | #include "Utiltensor.h"
  9 | #include "Pooling.h"
 10 | #include "UniLayer.h"
 11 | 
 12 | using namespace mshadow;
 13 | using namespace mshadow::expr;
 14 | using namespace mshadow::utils;
 15 | 
 16 | // This is re-implementment of the work of Zhou et al. (2016) in ACL.
 17 | // Attention-Based Bidirectional LSTM Networks for Relation Classification
 18 | 
 19 | template<typename xpu>
 20 | class AttentionZhouACL2016 {
 21 | 
 22 | public:
 23 | 	Tensor<xpu, 2, dtype> _omega;
 24 | 	Tensor<xpu, 2, dtype> _gradOmega;
 25 | 	Tensor<xpu, 2, dtype> _eg2Omega;
 26 | 
 27 | 	int _dw = 0;
 28 | 
 29 | 
 30 |   AttentionZhouACL2016() {
 31 |   }
 32 | 
 33 |   inline void initial(int inputAndOutputSize, int seed = 0) {
 34 | 	  _dw = inputAndOutputSize;
 35 | 
 36 | 
 37 | 	dtype bound = sqrt(6.0 / (_dw + 1));
 38 | 
 39 | 	_omega = NewTensor<xpu>(Shape2(1, _dw), d_zero);
 40 | 	_gradOmega = NewTensor<xpu>(Shape2(1, _dw), d_zero);
 41 | 	_eg2Omega = NewTensor<xpu>(Shape2(1, _dw), d_zero);
 42 | 
 43 | 
 44 | 	random(_omega, -1.0 * bound, 1.0 * bound, seed);
 45 |   }
 46 | 
 47 | 
 48 |   inline void release() {
 49 | 	    FreeSpace(&_omega);
 50 | 	    FreeSpace(&_gradOmega);
 51 | 	    FreeSpace(&_eg2Omega);
 52 |   }
 53 | 
 54 | 
 55 | public:
 56 | 
 57 |   // assume that all the vector is row vector, so the formulas should be adjusted.
 58 |   inline void ComputeForwardScore(std::vector<Tensor<xpu, 2, dtype> >& H, std::vector<Tensor<xpu, 2, dtype> >& M,
 59 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
 60 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
 61 | 		  Tensor<xpu, 2, dtype> hStar) {
 62 | 
 63 |     int seq_size = H.size();
 64 |     if(seq_size == 0) return;
 65 | 
 66 | 
 67 | 
 68 |     for(int i=0;i<seq_size;i++) {
 69 |     	M[i] = F<nl_tanh>(H[i]); // M = tanh(H)
 70 |     	for(int j=0;j<_dw;j++)
 71 |     		omegaM[0][i] += _omega[0][j]*M[i][0][j]; // dot(_omega, M[i].T()); // t(w)*M
 72 |     }
 73 | 
 74 |     // alpha = softmax(t(w)*M)
 75 | /*    int optLabel = -1;
 76 |     for (int i = 0; i < seq_size; ++i) {
 77 |         if (optLabel < 0 || omegaM[0][i] > omegaM[0][optLabel])
 78 |           optLabel = i;
 79 |     }*/
 80 |     dtype sum = 0;
 81 |     //dtype maxScore = omegaM[0][optLabel];
 82 |     for (int i = 0; i < seq_size; ++i) {
 83 |     	exp_omegaM[0][i] = exp(omegaM[0][i] /*- maxScore*/);
 84 |     	sum += exp_omegaM[0][i];
 85 |     }
 86 |     for (int i = 0; i < seq_size; ++i) {
 87 |     	alpha[0][i] = exp_omegaM[0][i]/sum;
 88 |     }
 89 | 
 90 |     // r = H*t(alpha)
 91 |     for(int i = 0; i < _dw; ++i) {
 92 |     	for(int j=0; j<seq_size; j++) {
 93 |     		r[0][i] += H[j][0][i]*alpha[0][j];
 94 |     	}
 95 |     }
 96 | 
 97 |     // h* = tanh(r)
 98 |     hStar = F<nl_tanh>(r);
 99 | 
100 | /*    for(int i = 0; i < _dw; ++i) {
101 |     	for(int j=0;j<seq_size;j++)
102 |     		hStar[0][i] += H[j][0][i];
103 |     }*/
104 | 
105 |   }
106 | 
107 | 
108 | 
109 |   inline void ComputeBackwardLoss(std::vector<Tensor<xpu, 2, dtype> >& H, std::vector<Tensor<xpu, 2, dtype> >& M,
110 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
111 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
112 | 		  Tensor<xpu, 2, dtype> hStar, Tensor<xpu, 2, dtype> lhStar,
113 | 		  std::vector<Tensor<xpu, 2, dtype> >& lH, bool bclear = false) {
114 | 
115 | 	  int seq_size = H.size();
116 | 	  if(seq_size == 0) return;
117 | 
118 |     if(bclear){
119 |       for (int idx = 0; idx < seq_size; idx++) {
120 |     	  lH[idx] = 0.0;
121 |       }
122 |     }
123 | 
124 | 
125 | 
126 |     Tensor<xpu, 2, dtype> lr = NewTensor<xpu>(Shape2(r.size(0), r.size(1)), d_zero);
127 |     lr += lhStar * F<nl_dtanh>(hStar);
128 | 
129 |     Tensor<xpu, 2, dtype> lalpha = NewTensor<xpu>(Shape2(alpha.size(0), alpha.size(1)), d_zero);
130 |     for(int i = 0; i < _dw; ++i) {
131 |     	for(int j=0; j<seq_size; j++) {
132 |     		lH[j][0][i] += lr[0][i] * alpha[0][j];
133 |     		lalpha[0][j] += lr[0][i] * H[j][0][i];
134 |     	}
135 |     }
136 | 
137 |     Tensor<xpu, 2, dtype> lOmegaM = NewTensor<xpu>(Shape2(omegaM.size(0), omegaM.size(1)), d_zero);
138 |     for (int i = 0; i < seq_size; ++i) {
139 |     	for(int j=0;j<seq_size;j++) {
140 |     		if(j==i)
141 |     			lOmegaM[0][i] += lalpha[0][j] * alpha[0][j] * (1-alpha[0][j]);
142 |     		else
143 |     			lOmegaM[0][i] += lalpha[0][j] * (-alpha[0][j]*alpha[0][i]);
144 |     	}
145 |     }
146 | 
147 |     std::vector<Tensor<xpu, 2, dtype> > lM(seq_size);
148 |     for (int idx = 0; idx < seq_size; idx++) {
149 |       lM[idx] = NewTensor<xpu>(Shape2(M[idx].size(0), M[idx].size(1)), d_zero);
150 |     }
151 |     for(int i=0;i<seq_size;i++) {
152 | 		_gradOmega += lOmegaM[0][i] * M[i];
153 | 		lM[i] += lOmegaM[0][i] * _omega;
154 | 		lH[i] += lM[i] * F<nl_dtanh>(M[i]);
155 | 	}
156 | 
157 | 
158 |     FreeSpace(&lr);
159 |     FreeSpace(&lalpha);
160 |     FreeSpace(&lOmegaM);
161 |     for (int idx = 0; idx < seq_size; idx++) {
162 |       FreeSpace(&(lM[idx]));
163 |     }
164 | 
165 | /*    for(int i = 0; i < _dw; ++i) {
166 |     	for(int j=0;j<seq_size;j++)
167 |     		lH[j][0][i] += lhStar[0][i];
168 |     }*/
169 | 
170 | 
171 | 
172 |   }
173 | 
174 | 
175 |   inline void ComputeForwardScore(Tensor<xpu, 3, dtype>  H, Tensor<xpu, 3, dtype>  M,
176 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
177 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
178 | 		  Tensor<xpu, 2, dtype> hStar) {
179 | 
180 |     int seq_size = H.size(0);
181 |     if(seq_size == 0) return;
182 | 
183 | 
184 | 
185 |     for(int i=0;i<seq_size;i++) {
186 |     	M[i] = F<nl_tanh>(H[i]); // M = tanh(H)
187 |     	for(int j=0;j<_dw;j++)
188 |     		omegaM[0][i] += _omega[0][j]*M[i][0][j]; // dot(_omega, M[i].T()); // t(w)*M
189 |     }
190 | 
191 |     // alpha = softmax(t(w)*M)
192 |     dtype sum = 0;
193 |     for (int i = 0; i < seq_size; ++i) {
194 |     	exp_omegaM[0][i] = exp(omegaM[0][i] );
195 |     	sum += exp_omegaM[0][i];
196 |     }
197 |     for (int i = 0; i < seq_size; ++i) {
198 |     	alpha[0][i] = exp_omegaM[0][i]/sum;
199 |     }
200 | 
201 |     // r = H*t(alpha)
202 |     for(int i = 0; i < _dw; ++i) {
203 |     	for(int j=0; j<seq_size; j++) {
204 |     		r[0][i] += H[j][0][i]*alpha[0][j];
205 |     	}
206 |     }
207 | 
208 |     // h* = tanh(r)
209 |     hStar = F<nl_tanh>(r);
210 | 
211 | 
212 |   }
213 | 
214 | 
215 | 
216 |   inline void ComputeBackwardLoss(Tensor<xpu, 3, dtype> H, Tensor<xpu, 3, dtype> M,
217 | 		  Tensor<xpu, 2, dtype> omegaM, Tensor<xpu, 2, dtype> exp_omegaM,
218 | 		  Tensor<xpu, 2, dtype> alpha, Tensor<xpu, 2, dtype> r,
219 | 		  Tensor<xpu, 2, dtype> hStar, Tensor<xpu, 2, dtype> lhStar,
220 | 		  Tensor<xpu, 3, dtype> lH, bool bclear = false) {
221 | 
222 | 	  int seq_size = H.size(0);
223 | 	  if(seq_size == 0) return;
224 | 
225 |     if(bclear){
226 |       for (int idx = 0; idx < seq_size; idx++) {
227 |     	  lH[idx] = 0.0;
228 |       }
229 |     }
230 | 
231 | 
232 | 
233 |     Tensor<xpu, 2, dtype> lr = NewTensor<xpu>(Shape2(r.size(0), r.size(1)), d_zero);
234 |     lr += lhStar * F<nl_dtanh>(hStar);
235 | 
236 |     Tensor<xpu, 2, dtype> lalpha = NewTensor<xpu>(Shape2(alpha.size(0), alpha.size(1)), d_zero);
237 |     for(int i = 0; i < _dw; ++i) {
238 |     	for(int j=0; j<seq_size; j++) {
239 |     		lH[j][0][i] += lr[0][i] * alpha[0][j];
240 |     		lalpha[0][j] += lr[0][i] * H[j][0][i];
241 |     	}
242 |     }
243 | 
244 |     Tensor<xpu, 2, dtype> lOmegaM = NewTensor<xpu>(Shape2(omegaM.size(0), omegaM.size(1)), d_zero);
245 |     for (int i = 0; i < seq_size; ++i) {
246 |     	for(int j=0;j<seq_size;j++) {
247 |     		if(j==i)
248 |     			lOmegaM[0][i] += lalpha[0][j] * alpha[0][j] * (1-alpha[0][j]);
249 |     		else
250 |     			lOmegaM[0][i] += lalpha[0][j] * (-alpha[0][j]*alpha[0][i]);
251 |     	}
252 |     }
253 | 
254 |     std::vector<Tensor<xpu, 2, dtype> > lM(seq_size);
255 |     for (int idx = 0; idx < seq_size; idx++) {
256 |       lM[idx] = NewTensor<xpu>(Shape2(M[idx].size(0), M[idx].size(1)), d_zero);
257 |     }
258 |     for(int i=0;i<seq_size;i++) {
259 | 		_gradOmega += lOmegaM[0][i] * M[i];
260 | 		lM[i] += lOmegaM[0][i] * _omega;
261 | 		lH[i] += lM[i] * F<nl_dtanh>(M[i]);
262 | 	}
263 | 
264 | 
265 |     FreeSpace(&lr);
266 |     FreeSpace(&lalpha);
267 |     FreeSpace(&lOmegaM);
268 |     for (int idx = 0; idx < seq_size; idx++) {
269 |       FreeSpace(&(lM[idx]));
270 |     }
271 | 
272 | 
273 |   }
274 | 
275 | 
276 | 
277 |   inline void updateAdaGrad(dtype regularizationWeight, dtype adaAlpha, dtype adaEps) {
278 |     _gradOmega = _gradOmega + _omega * regularizationWeight;
279 |     _eg2Omega= _eg2Omega + _gradOmega * _gradOmega;
280 |     _omega = _omega - _gradOmega * adaAlpha / F<nl_sqrt>(_eg2Omega + adaEps);
281 | 
282 |     clearGrad();
283 |   }
284 | 
285 |   inline void clearGrad() {
286 |     _gradOmega = 0;
287 |   }
288 | 
289 | 
290 | };
291 | 
292 | #endif
293 | 


--------------------------------------------------------------------------------
/ade/utils.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef UTILS_H_
  3 | #define UTILS_H_
  4 | 
  5 | 
  6 | #include <stdio.h>
  7 | #include <vector>
  8 | #include "Word2Vec.h"
  9 | #include "Utf.h"
 10 | #include "Entity.h"
 11 | #include "Relation.h"
 12 | #include "Token.h"
 13 | #include "FoxUtil.h"
 14 | #include <dirent.h>
 15 | #include <sys/types.h>
 16 | #include <sys/stat.h>
 17 | #include <list>
 18 | #include <sstream>
 19 | #include "ADEsentence.h"
 20 | #include "Sent.h"
 21 | 
 22 | using namespace std;
 23 | 
 24 | #define USE_IMP 0
 25 | 
 26 | // schema BILOU, three entity types (Bacteria,Habitat,Geographical)
 27 | #define TYPE_Disease "Disease"
 28 | #define TYPE_Chemical "Chemical"
 29 | #define MAX_ENTITY 9
 30 | #define B_Disease "B_Disease"
 31 | #define I_Disease "I_Disease"
 32 | #define L_Disease "L_Disease"
 33 | #define U_Disease "U_Disease"
 34 | #define B_Chemical "B_Chemical"
 35 | #define I_Chemical "I_Chemical"
 36 | #define L_Chemical "L_Chemical"
 37 | #define U_Chemical "U_Chemical"
 38 | #define OTHER "O"
 39 | 
 40 | 
 41 | void appendEntity(const fox::Token& token, Entity& entity) {
 42 | 	int whitespacetoAdd = token.begin-entity.end;
 43 | 	for(int j=0;j<whitespacetoAdd;j++)
 44 | 		entity.text += " ";
 45 | 	entity.text += token.word;
 46 | 	entity.end = token.end;
 47 | }
 48 | 
 49 | void newEntity(const fox::Token& token, const string& labelName, Entity& entity) {
 50 | 	entity.type = labelName.substr(labelName.find("_")+1);
 51 | 	entity.begin = token.begin;
 52 | 	entity.end = token.end;
 53 | 	entity.text = token.word;
 54 | }
 55 | 
 56 | int NERlabelName2labelID(const string& labelName) {
 57 | 	if(labelName == B_Disease) {
 58 | 		return 0;
 59 | 	} else if(labelName == I_Disease) {
 60 | 		return 1;
 61 | 	} else if(labelName == L_Disease) {
 62 | 		return 2;
 63 | 	} else if(labelName == U_Disease) {
 64 | 		return 3;
 65 | 	} else if(labelName == B_Chemical) {
 66 | 		return 4;
 67 | 	} else if(labelName == I_Chemical) {
 68 | 		return 5;
 69 | 	} else if(labelName == L_Chemical) {
 70 | 		return 6;
 71 | 	} else if(labelName == U_Chemical) {
 72 | 		return 7;
 73 | 	} else
 74 | 		return 8;
 75 | }
 76 | 
 77 | string NERlabelID2labelName(const int labelID) {
 78 | 	if(labelID == 0) {
 79 | 		return B_Disease;
 80 | 	} else if(labelID == 1) {
 81 | 		return I_Disease;
 82 | 	} else if(labelID == 2) {
 83 | 		return L_Disease;
 84 | 	} else if(labelID == 3) {
 85 | 		return U_Disease;
 86 | 	} else if(labelID == 4) {
 87 | 		return B_Chemical;
 88 | 	} else if(labelID == 5) {
 89 | 		return I_Chemical;
 90 | 	} else if(labelID == 6) {
 91 | 		return L_Chemical;
 92 | 	} else if(labelID == 7) {
 93 | 		return U_Chemical;
 94 | 	} else
 95 | 		return OTHER;
 96 | }
 97 | 
 98 | // two relation type (Lives_In or not)
 99 | #if USE_IMP
100 | 
101 | 	#define MAX_RELATION 4
102 | 	#define ADE "ADE"
103 | 	#define Not_ADE "Not_ADE"
104 | 	#define IMP_Disease "IMP_Disease"
105 | 	#define IMP_Chemical "IMP_Chemical"
106 | 
107 | #else
108 | 
109 | #define MAX_RELATION 2
110 | #define ADE "ADE"
111 | #define Not_ADE "Not_ADE"
112 | 
113 | #endif
114 | 
115 | int RellabelName2labelID(const string& labelName) {
116 | #if USE_IMP
117 | 
118 | 	if(labelName == ADE) {
119 | 		return 0;
120 | 	} else if(labelName == IMP_Disease)
121 | 		return 1;
122 | 	else if(labelName == IMP_Chemical)
123 | 		return 2;
124 | 	else
125 | 		return 3;
126 | 
127 | #else
128 | 	if(labelName == ADE) {
129 | 		return 0;
130 | 	} else
131 | 		return 1;
132 | #endif
133 | }
134 | 
135 | string RellabelID2labelName(const int labelID) {
136 | #if USE_IMP
137 | 
138 | 	if(labelID == 0) {
139 | 		return ADE;
140 | 	} else if(labelID == 1)
141 | 		return IMP_Disease;
142 | 	else if(labelID == 2)
143 | 		return IMP_Chemical;
144 | 	else
145 | 		return Not_ADE;
146 | 
147 | #else
148 | 	if(labelID == 0) {
149 | 		return ADE;
150 | 	} else
151 | 		return Not_ADE;
152 | #endif
153 | }
154 | 
155 | void newRelation(Relation& relation, const Entity& entity1, const Entity& entity2) {
156 | 
157 | 	relation.entity1 = entity1;
158 | 	relation.entity2 = entity2;
159 | }
160 | 
161 | void loadProcessedFile(const string& dirPath, vector < vector< fox::Sent > > & groups) {
162 | 
163 | 	struct dirent** namelist = NULL;
164 | 	int total = scandir(dirPath.c_str(), &namelist, 0, alphasort);
165 | 
166 | 	for(int i=0;i<total;i++) {
167 | 
168 | 		if (namelist[i]->d_type == 8) {
169 | 			//file
170 | 			if(namelist[i]->d_name[0]=='.')
171 | 				continue;
172 | 
173 | 			string filePath = dirPath;
174 | 			filePath += "/";
175 | 			filePath += namelist[i]->d_name;
176 | 			string fileName = namelist[i]->d_name;
177 | 
178 | 			ifstream ifs;
179 | 			ifs.open(filePath.c_str());
180 | 			fox::Sent sent;
181 | 			string line;
182 | 			vector<fox::Sent> group;
183 | 
184 | 			while(getline(ifs, line)) {
185 | 				if(line.empty()){
186 | 					// new line
187 | 					if(sent.tokens.size()!=0) {
188 | 						group.push_back(sent);
189 | 						sent.tokens.clear();
190 | 					}
191 | 				} else {
192 | 					vector<string> splitted;
193 | 					fox::split_bychar(line, splitted, '\t');
194 | 					fox::Token token;
195 | 					token.word = splitted[0];
196 | 					token.begin = atoi(splitted[1].c_str());
197 | 					token.end = atoi(splitted[2].c_str());
198 | 					token.pos = splitted[3];
199 | 					token.lemma = splitted[4];
200 | 					token.depGov = atoi(splitted[5].c_str());
201 | 					token.depType = splitted[6];
202 | 					sent.tokens.push_back(token);
203 | 				}
204 | 
205 | 
206 | 			}
207 | 
208 | 			ifs.close();
209 | 
210 | 			groups.push_back(group);
211 | 		}
212 | 	}
213 | 
214 | }
215 | 
216 | 
217 | void loadAnnotatedFile(const string& dirPath, vector< vector<ADEsentence> > & groups)
218 | {
219 | 	struct dirent** namelist = NULL;
220 | 	int total = scandir(dirPath.c_str(), &namelist, 0, alphasort);
221 | 
222 | 
223 | 	for(int i=0;i<total;i++) {
224 | 
225 | 		if (namelist[i]->d_type == 8) {
226 | 			//file
227 | 			if(namelist[i]->d_name[0]=='.')
228 | 				continue;
229 | 
230 | 			string filePath = dirPath;
231 | 			filePath += "/";
232 | 			filePath += namelist[i]->d_name;
233 | 			string fileName = namelist[i]->d_name;
234 | 
235 | 			vector<ADEsentence> group;
236 | 			ifstream ifs;
237 | 			ifs.open(filePath.c_str());
238 | 			string line;
239 | 			ADEsentence sentence;
240 | 
241 | 			while(getline(ifs, line)) {
242 | 				if(line.empty()) {
243 | 					group.push_back(sentence);
244 | 					sentence.clear();
245 | 				} else {
246 | 					vector<string> splitted;
247 | 					fox::split_bychar(line, splitted, '\t');
248 | 					if(splitted[0]=="offset") {
249 | 						sentence.offset = atoi(splitted[1].c_str());
250 | 					} else if(splitted[0]=="EN") {
251 | 						Entity entity;
252 | 						entity.text = splitted[1];
253 | 						entity.type = splitted[2];
254 | 						entity.begin = atoi(splitted[3].c_str());
255 | 						entity.end = atoi(splitted[4].c_str());
256 | 						sentence.entities.push_back(entity);
257 | 					} else if(splitted[0]=="ADE") {
258 | 						Entity entity1;
259 | 						entity1.text = splitted[1];
260 | 						entity1.type = TYPE_Disease;
261 | 						entity1.begin = atoi(splitted[2].c_str());
262 | 						entity1.end = atoi(splitted[3].c_str());
263 | 						Entity entity2;
264 | 						entity2.text = splitted[4];
265 | 						entity2.type = TYPE_Chemical;
266 | 						entity2.begin = atoi(splitted[5].c_str());
267 | 						entity2.end = atoi(splitted[6].c_str());
268 | 						Relation relation;
269 | 						relation.entity1 = entity1;
270 | 						relation.entity2 = entity2;
271 | 						sentence.relations.push_back(relation);
272 | 					} else {
273 | 						sentence.text = splitted[0];
274 | 					}
275 | 				}
276 | 
277 | 			}
278 | 
279 | 			ifs.close();
280 | 
281 | 			groups.push_back(group);
282 | 
283 | 		}
284 | 	}
285 | 
286 | 
287 | 
288 | 
289 | }
290 | 
291 | 
292 | bool isTokenBeforeEntity(const fox::Token& tok, const Entity& entity) {
293 | 	if(tok.begin<entity.begin)
294 | 		return true;
295 | 	else
296 | 		return false;
297 | }
298 | 
299 | bool isTokenAfterEntity(const fox::Token& tok, const Entity& entity) {
300 | 	if(entity.end2 == -1) {
301 | 		if(tok.end>entity.end)
302 | 			return true;
303 | 		else
304 | 			return false;
305 | 
306 | 	} else {
307 | 		if(tok.end>entity.end2)
308 | 			return true;
309 | 		else
310 | 			return false;
311 | 
312 | 	}
313 | 
314 | }
315 | 
316 | 
317 | string isTokenInEntity(const fox::Token& tok, const Entity& entity) {
318 | 
319 | 	if(tok.begin==entity.begin && tok.end==entity.end)
320 | 		return "U";
321 | 	else if(tok.begin==entity.begin)
322 | 		return "B";
323 | 	else if(tok.end==entity.end)
324 | 		return "L";
325 | 	else if(tok.begin>entity.begin && tok.end<entity.end)
326 | 		return "I";
327 | 	else
328 | 		return "O";
329 | 
330 | }
331 | 
332 | bool boolTokenInEntity(const fox::Token& tok, const Entity& entity) {
333 | 
334 | 	if(entity.end2 == -1) {
335 | 		if(tok.begin>=entity.begin && tok.end<=entity.end)
336 | 			return true;
337 | 		else
338 | 			return false;
339 | 	} else {
340 | 
341 | 		if((tok.begin>=entity.begin && tok.end<=entity.end) ||
342 | 				(tok.begin>=entity.begin2 && tok.end<=entity.end2))
343 | 			return true;
344 | 		else
345 | 			return false;
346 | 
347 | 	}
348 | }
349 | 
350 | bool isTokenBetweenTwoEntities(const fox::Token& tok, const Entity& former, const Entity& latter) {
351 | 
352 | 	if(former.end2 == -1) {
353 | 		if(tok.begin>=former.end && tok.end<=latter.begin)
354 | 			return true;
355 | 		else
356 | 			return false;
357 | 	} else {
358 | 		if(tok.begin>=former.end2 && tok.end<=latter.begin)
359 | 			return true;
360 | 		else
361 | 			return false;
362 | 	}
363 | }
364 | 
365 | 
366 | void deleteEntity(vector<Entity>& entities, const Entity& target)
367 | {
368 | 	vector<Entity>::iterator iter = entities.begin();
369 | 	for(;iter!=entities.end();iter++) {
370 | 		if((*iter).equals(target)) {
371 | 			break;
372 | 		}
373 | 	}
374 | 	if(iter!=entities.end()) {
375 | 		entities.erase(iter);
376 | 	}
377 | }
378 | 
379 | int containsEntity(vector<Entity>& source, const Entity& target) {
380 | 
381 | 	for(int i=0;i<source.size();i++) {
382 | 		if(source[i].equals(target))
383 | 			return i;
384 | 
385 | 	}
386 | 
387 | 	return -1;
388 | }
389 | 
390 | int containsRelation(vector<Relation>& source, const Relation& target) {
391 | 
392 | 	for(int i=0;i<source.size();i++) {
393 | 		if(source[i].equals(target))
394 | 			return i;
395 | 
396 | 	}
397 | 
398 | 	return -1;
399 | }
400 | 
401 | int relationContainsEntity(vector<Relation>& source, const Entity& target) {
402 | 
403 | 	for(int i=0;i<source.size();i++) {
404 | 		if(source[i].entity1.equals(target))
405 | 			return i;
406 | 		else if(source[i].entity2.equals(target))
407 | 			return i;
408 | 
409 | 	}
410 | 
411 | 	return -1;
412 | }
413 | 
414 | 
415 | bool isADE(const Entity& disease, const Entity& chemical, const ADEsentence & sent) {
416 | 
417 | 	for(int i=0;i<sent.relations.size();i++) {
418 | 		if(sent.relations[i].entity1.equals(disease) && sent.relations[i].entity2.equals(chemical))
419 | 			return true;
420 | 	}
421 | 
422 | 	return false;
423 | 
424 | }
425 | 
426 | double precision(int correct, int predict) {
427 | 	return 1.0*correct/predict;
428 | }
429 | 
430 | double recall(int correct, int gold) {
431 | 	return 1.0*correct/gold;
432 | }
433 | 
434 | double f1(int correct, int gold, int predict) {
435 | 	double p = precision(correct, predict);
436 | 	double r = recall(correct, gold);
437 | 
438 | 	return 2*p*r/(p+r);
439 | }
440 | 
441 | double f1(double p, double r) {
442 | 
443 | 	return 2*p*r/(p+r);
444 | }
445 | 
446 | 
447 | 
448 | 
449 | #endif /* UTILS_H_ */
450 | 


--------------------------------------------------------------------------------
/bb3/utils.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef UTILS_H_
  3 | #define UTILS_H_
  4 | 
  5 | 
  6 | #include <stdio.h>
  7 | #include <vector>
  8 | #include "Word2Vec.h"
  9 | #include "Utf.h"
 10 | #include "Entity.h"
 11 | #include "Token.h"
 12 | #include "FoxUtil.h"
 13 | #include <dirent.h>
 14 | #include <sys/types.h>
 15 | #include <sys/stat.h>
 16 | #include "Document.h"
 17 | #include "NerExample.h"
 18 | #include <list>
 19 | #include <sstream>
 20 | 
 21 | using namespace std;
 22 | 
 23 | #define USE_IMP 0
 24 | 
 25 | // schema BILOU, three entity types (Bacteria,Habitat,Geographical)
 26 | #define TYPE_Bac "Bacteria"
 27 | #define TYPE_Hab "Habitat"
 28 | #define TYPE_Geo "Geographical"
 29 | #define MAX_ENTITY 13
 30 | #define B_Bacteria "B_Bacteria"
 31 | #define I_Bacteria "I_Bacteria"
 32 | #define L_Bacteria "L_Bacteria"
 33 | #define U_Bacteria "U_Bacteria"
 34 | #define B_Habitat "B_Habitat"
 35 | #define I_Habitat "I_Habitat"
 36 | #define L_Habitat "L_Habitat"
 37 | #define U_Habitat "U_Habitat"
 38 | #define B_Geographical "B_Geographical"
 39 | #define I_Geographical "I_Geographical"
 40 | #define L_Geographical "L_Geographical"
 41 | #define U_Geographical "U_Geographical"
 42 | #define OTHER "O"
 43 | 
 44 | 
 45 | void appendEntity(const fox::Token& token, Entity& entity) {
 46 | 	int whitespacetoAdd = token.begin-entity.end;
 47 | 	for(int j=0;j<whitespacetoAdd;j++)
 48 | 		entity.text += " ";
 49 | 	entity.text += token.word;
 50 | 	entity.end = token.end;
 51 | }
 52 | 
 53 | void newEntity(const fox::Token& token, const string& labelName, Entity& entity, int entityId) {
 54 | 	stringstream ss;
 55 | 	ss<<"T"<<entityId;
 56 | 	entity.id = ss.str();
 57 | 	entity.type = labelName.substr(labelName.find("_")+1);
 58 | 	entity.begin = token.begin;
 59 | 	entity.end = token.end;
 60 | 	entity.text = token.word;
 61 | }
 62 | 
 63 | int NERlabelName2labelID(const string& labelName) {
 64 | 	if(labelName == B_Bacteria) {
 65 | 		return 0;
 66 | 	} else if(labelName == I_Bacteria) {
 67 | 		return 1;
 68 | 	} else if(labelName == L_Bacteria) {
 69 | 		return 2;
 70 | 	} else if(labelName == U_Bacteria) {
 71 | 		return 3;
 72 | 	} else if(labelName == B_Habitat) {
 73 | 		return 4;
 74 | 	} else if(labelName == I_Habitat) {
 75 | 		return 5;
 76 | 	} else if(labelName == L_Habitat) {
 77 | 		return 6;
 78 | 	} else if(labelName == U_Habitat) {
 79 | 		return 7;
 80 | 	} else if(labelName == B_Geographical) {
 81 | 		return 8;
 82 | 	} else if(labelName == I_Geographical)
 83 | 		return 9;
 84 | 	else if(labelName == L_Geographical)
 85 | 			return 10;
 86 | 	else if(labelName == U_Geographical)
 87 | 			return 11;
 88 | 	else
 89 | 		return 12;
 90 | }
 91 | 
 92 | string NERlabelID2labelName(const int labelID) {
 93 | 	if(labelID == 0) {
 94 | 		return B_Bacteria;
 95 | 	} else if(labelID == 1) {
 96 | 		return I_Bacteria;
 97 | 	} else if(labelID == 2) {
 98 | 		return L_Bacteria;
 99 | 	} else if(labelID == 3) {
100 | 		return U_Bacteria;
101 | 	} else if(labelID == 4) {
102 | 		return B_Habitat;
103 | 	} else if(labelID == 5) {
104 | 		return I_Habitat;
105 | 	} else if(labelID == 6) {
106 | 		return L_Habitat;
107 | 	} else if(labelID == 7) {
108 | 		return U_Habitat;
109 | 	} else if(labelID == 8) {
110 | 		return B_Geographical;
111 | 	} else if(labelID == 9)
112 | 		return I_Geographical;
113 | 	else if(labelID == 10)
114 | 			return L_Geographical;
115 | 	else if(labelID == 11)
116 | 			return U_Geographical;
117 | 	else
118 | 		return OTHER;
119 | }
120 | 
121 | // two relation type (Lives_In or not)
122 | #if USE_IMP
123 | 
124 | 	#define MAX_RELATION 4
125 | 	#define Lives_In "Lives_In"
126 | 	#define Not_Lives_In "Not_Lives_In"
127 | 	#define IMP_BAC "IMP_BAC"
128 | 	#define IMP_LOC "IMP_LOC"
129 | 
130 | #else
131 | 
132 | #define MAX_RELATION 2
133 | #define Lives_In "Lives_In"
134 | #define Not_Lives_In "Not_Lives_In"
135 | 
136 | #endif
137 | 
138 | int RellabelName2labelID(const string& labelName) {
139 | #if USE_IMP
140 | 
141 | 	if(labelName == Lives_In) {
142 | 		return 0;
143 | 	} else if(labelName == IMP_BAC)
144 | 		return 1;
145 | 	else if(labelName == IMP_LOC)
146 | 		return 2;
147 | 	else
148 | 		return 3;
149 | 
150 | #else
151 | 	if(labelName == Lives_In) {
152 | 		return 0;
153 | 	} else
154 | 		return 1;
155 | #endif
156 | }
157 | 
158 | string RellabelID2labelName(const int labelID) {
159 | #if USE_IMP
160 | 
161 | 	if(labelID == 0) {
162 | 		return Lives_In;
163 | 	} else if(labelID == 1)
164 | 		return IMP_BAC;
165 | 	else if(labelID == 2)
166 | 		return IMP_LOC;
167 | 	else
168 | 		return Not_Lives_In;
169 | 
170 | #else
171 | 	if(labelID == 0) {
172 | 		return Lives_In;
173 | 	} else
174 | 		return Not_Lives_In;
175 | #endif
176 | }
177 | 
178 | void newRelation(Relation& relation, const Entity& bac, const Entity& loc, int relationId) {
179 | 	stringstream ss;
180 | 	ss<<"R"<<relationId;
181 | 	relation.id = ss.str();
182 | 	relation.idBacteria = bac.id;
183 | 	relation.idLocation = loc.id;
184 | 
185 | 	relation.bacteria = bac;
186 | 	relation.location = loc;
187 | }
188 | 
189 | void outputResults(const string& id, vector<Entity>& entities, vector<Relation>& relations, const string& dir) {
190 | 	ofstream m_outf;
191 | 	string path = dir+"/BB-event+ner-"+id+".a2";
192 | 	m_outf.open(path.c_str());
193 | 
194 | 	for(int i=0;i<entities.size();i++) {
195 | 
196 | 		m_outf << entities[i].id << "\t"<< entities[i].type<<" "<<entities[i].begin<<" "<<
197 | 				entities[i].end<<"\t"<<entities[i].text<<endl;
198 | 
199 | 	}
200 | 
201 | 	for(int i=0;i<relations.size();i++) {
202 | 		m_outf << relations[i].id << "\t"<< "Lives_In"<<" Bacteria:"<<relations[i].idBacteria<<
203 | 			" Location:"<<relations[i].idLocation<<endl;
204 | 	}
205 | 
206 | 	m_outf.close();
207 | }
208 | 
209 | void outputEnityResults(const string& id, vector<Entity>& entities, const string& dir) {
210 | 	ofstream m_outf;
211 | 	string path = dir+"/BB-event+ner-"+id+".a2";
212 | 	m_outf.open(path.c_str());
213 | 
214 | 	int count=1;
215 | 	for(int i=0;i<entities.size();i++) {
216 | 
217 | 		m_outf << entities[i].id << "\t"<< entities[i].type<<" "<<entities[i].begin<<" "<<
218 | 				entities[i].end<<"\t"<<entities[i].text<<endl;
219 | 
220 | 		count++;
221 | 	}
222 | 	m_outf.close();
223 | }
224 | 
225 | int findEntityById(const string& id, const vector<Entity>& entities) {
226 | 
227 | 	for(int i=0;i<entities.size();i++) {
228 | 		if(entities[i].id==id) {
229 | 			return i;
230 | 		}
231 | 
232 | 	}
233 | 
234 | 	return -1;
235 | }
236 | 
237 | void loadNlpFile(const string& dirPath, vector<Document>& docs) {
238 | 
239 | 	struct dirent** namelist = NULL;
240 | 	int total = scandir(dirPath.c_str(), &namelist, 0, alphasort);
241 | 	int count = 0;
242 | 
243 | 	for(int i=0;i<total;i++) {
244 | 
245 | 		if (namelist[i]->d_type == 8) {
246 | 			//file
247 | 			if(namelist[i]->d_name[0]=='.')
248 | 				continue;
249 | 
250 | 			string filePath = dirPath;
251 | 			filePath += "/";
252 | 			filePath += namelist[i]->d_name;
253 | 			string fileName = namelist[i]->d_name;
254 | 
255 | 			ifstream ifs;
256 | 			ifs.open(filePath.c_str());
257 | 			fox::Sent sent;
258 | 			string line;
259 | 
260 | 
261 | 			while(getline(ifs, line)) {
262 | 				if(line.empty()){
263 | 					// new line
264 | 					if(sent.tokens.size()!=0) {
265 | 						docs[count].sents.push_back(sent);
266 | 						docs[count].sents[docs[count].sents.size()-1].begin = sent.tokens[0].begin;
267 | 						docs[count].sents[docs[count].sents.size()-1].end = sent.tokens[sent.tokens.size()-1].end;
268 | 						sent.tokens.clear();
269 | 					}
270 | 				} else {
271 | 					vector<string> splitted;
272 | 					fox::split_bychar(line, splitted, '\t');
273 | 					fox::Token token;
274 | 					token.word = splitted[0];
275 | 					token.begin = atoi(splitted[1].c_str());
276 | 					token.end = atoi(splitted[2].c_str());
277 | 					token.pos = splitted[3];
278 | 					token.lemma = splitted[4];
279 | 					token.depGov = atoi(splitted[5].c_str());
280 | 					token.depType = splitted[6];
281 | 					sent.tokens.push_back(token);
282 | 				}
283 | 
284 | 
285 | 
286 | 			}
287 | 
288 | 			ifs.close();
289 | 			count++;
290 | 		}
291 | 	}
292 | 
293 | }
294 | 
295 | bool isEntityOverlapped(const Entity& former, const Entity& latter) {
296 | 	if(former.end2==-1) {
297 | 		if(former.end<=latter.begin)
298 | 			return false;
299 | 		else
300 | 			return true;
301 | 	} else {
302 | 		if(former.end2<=latter.begin)
303 | 			return false;
304 | 		else
305 | 			return true;
306 | 	}
307 | }
308 | 
309 | 
310 | int parseBB3(const string& dirPath, vector<Document>& documents)
311 | {
312 | 	struct dirent** namelist = NULL;
313 | 	int total = scandir(dirPath.c_str(), &namelist, 0, alphasort);
314 | 
315 | 
316 | 	for(int i=0;i<total;i++) {
317 | 
318 | 		if (namelist[i]->d_type == 8) {
319 | 			//file
320 | 			if(namelist[i]->d_name[0]=='.')
321 | 				continue;
322 | 
323 | 			string filePath = dirPath;
324 | 			filePath += "/";
325 | 			filePath += namelist[i]->d_name;
326 | 			string fileName = namelist[i]->d_name;
327 | 
328 | 			if(string::npos != filePath.find(".a1")) { // doc
329 | 				Document doc;
330 | 				doc.id = fileName.substr(fileName.find_last_of("-")+1, fileName.find(".")-fileName.find_last_of("-")-1);
331 | 				doc.maxParagraphId = -1;
332 | 				ifstream ifs;
333 | 				ifs.open(filePath.c_str());
334 | 				string line;
335 | 				while(getline(ifs, line)) {
336 | 
337 | 					if(!line.empty() && line[0]=='T') {
338 | 						if(doc.maxParagraphId < atoi(line.substr(1,1).c_str()))
339 | 							doc.maxParagraphId = atoi(line.substr(1,1).c_str());
340 | 					}
341 | 				}
342 | 
343 | 				ifs.close();
344 | 
345 | 				documents.push_back(doc);
346 | 			} else if(string::npos != filePath.find(".a2")) { // entity && relation
347 | 				Document& doc = documents[documents.size()-1];
348 | 
349 | 				ifstream ifs;
350 | 				ifs.open(filePath.c_str());
351 | 
352 | 
353 | 				string line;
354 | 				while(getline(ifs, line)) {
355 | 
356 | 					if(!line.empty()) {
357 | 
358 | 						if(line[0] == 'T') { // entity
359 | 							vector<string> splitted;
360 | 							fox::split_bychar(line, splitted, '\t');
361 | 							Entity entity;
362 | 							entity.id = splitted[0];
363 | 							entity.text = splitted[2];
364 | 
365 | 							vector<string> temp1;
366 | 							fox::split(splitted[1], temp1, " |;");
367 | 
368 | 							if(temp1.size() == 3) {
369 | 								entity.type = temp1[0];
370 | 								entity.begin = atoi(temp1[1].c_str());
371 | 								entity.end = atoi(temp1[2].c_str());
372 | 
373 | 								if(doc.entities.size()>0) {
374 | 									Entity& former = doc.entities[doc.entities.size()-1];
375 | 									if(isEntityOverlapped(former, entity)) {
376 | 										// if two entities is overlapped, we keep the one with narrow range
377 | 										int formerRange = former.end-former.begin;
378 | 										int entityRange = entity.end-entity.begin;
379 | 										if(entityRange<formerRange) {
380 | 											doc.entities.pop_back();
381 | 											doc.entities.push_back(entity);
382 | 										}
383 | 									} else
384 | 										doc.entities.push_back(entity);
385 | 								} else
386 | 									doc.entities.push_back(entity);
387 | 
388 | /*								cout<<"dump entity#####"<<endl;
389 | 								for(int i=0;i<doc.entities.size();i++)
390 | 									cout<<doc.entities[i].id<<endl;*/
391 | 
392 | 							} else { // non-continuous entity is ignored
393 | 
394 | /*								entity.type = temp1[0];
395 | 								entity.begin = atoi(temp1[1].c_str());
396 | 								entity.end = atoi(temp1[2].c_str());
397 | 								entity.begin2 = atoi(temp1[3].c_str());
398 | 								entity.end2 = atoi(temp1[4].c_str());
399 | 								doc.entities.push_back(entity);*/
400 | 							}
401 | 
402 | 						} else if(line[0] == 'R') { //relation
403 | 							vector<string> splitted;
404 | 							fox::split(line, splitted, "\t| |:");
405 | 							Relation relation;
406 | 
407 | 							relation.idBacteria = splitted[3];
408 | 							relation.idLocation = splitted[5];
409 | 
410 | 
411 | 							int idxBac = findEntityById(relation.idBacteria, doc.entities);
412 | 							int idxLoc = findEntityById(relation.idLocation, doc.entities);
413 | 							if(idxBac ==-1 || idxLoc == -1)
414 | 								continue; // we get rid of some entities
415 | 
416 | 							relation.bacteria = doc.entities[idxBac];
417 | 							relation.location = doc.entities[idxLoc];
418 | 
419 | 							doc.relations.push_back(relation);
420 | 						}
421 | 
422 | 					}
423 | 				}
424 | 				ifs.close();
425 | 
426 | 			}
427 | 
428 | 		}
429 | 	}
430 | 
431 | 
432 |     return 0;
433 | 
434 | }
435 | 
436 | 
437 | bool isTokenBeforeEntity(const fox::Token& tok, const Entity& entity) {
438 | 	if(tok.begin<entity.begin)
439 | 		return true;
440 | 	else
441 | 		return false;
442 | }
443 | 
444 | bool isTokenAfterEntity(const fox::Token& tok, const Entity& entity) {
445 | 	if(entity.end2 == -1) {
446 | 		if(tok.end>entity.end)
447 | 			return true;
448 | 		else
449 | 			return false;
450 | 
451 | 	} else {
452 | 		if(tok.end>entity.end2)
453 | 			return true;
454 | 		else
455 | 			return false;
456 | 
457 | 	}
458 | 
459 | }
460 | 
461 | 
462 | string isTokenInEntity(const fox::Token& tok, const Entity& entity) {
463 | 
464 | 	if(tok.begin==entity.begin && tok.end==entity.end)
465 | 		return "U";
466 | 	else if(tok.begin==entity.begin)
467 | 		return "B";
468 | 	else if(tok.end==entity.end)
469 | 		return "L";
470 | 	else if(tok.begin>entity.begin && tok.end<entity.end)
471 | 		return "I";
472 | 	else
473 | 		return "O";
474 | 
475 | }
476 | 
477 | bool boolTokenInEntity(const fox::Token& tok, const Entity& entity) {
478 | 
479 | 	if(entity.end2 == -1) {
480 | 		if(tok.begin>=entity.begin && tok.end<=entity.end)
481 | 			return true;
482 | 		else
483 | 			return false;
484 | 	} else {
485 | 
486 | 		if((tok.begin>=entity.begin && tok.end<=entity.end) ||
487 | 				(tok.begin>=entity.begin2 && tok.end<=entity.end2))
488 | 			return true;
489 | 		else
490 | 			return false;
491 | 
492 | 	}
493 | }
494 | 
495 | bool isTokenBetweenTwoEntities(const fox::Token& tok, const Entity& former, const Entity& latter) {
496 | 
497 | 	if(former.end2 == -1) {
498 | 		if(tok.begin>=former.end && tok.end<=latter.begin)
499 | 			return true;
500 | 		else
501 | 			return false;
502 | 	} else {
503 | 		if(tok.begin>=former.end2 && tok.end<=latter.begin)
504 | 			return true;
505 | 		else
506 | 			return false;
507 | 	}
508 | }
509 | 
510 | // delete the entities not in the window sentence
511 | void deleteEntityOutOfWindow(vector<Entity>& entities, int begin, int end) {
512 | 
513 | 
514 | 	vector<Entity>::iterator iter = entities.begin();
515 | 	for(;iter!=entities.end();) {
516 | 		if((*iter).begin < begin || (*iter).end > end) {
517 | 			iter = entities.erase(iter);
518 | 		} else {
519 | 			iter++;
520 | 		}
521 | 	}
522 | 
523 | }
524 | 
525 | void findEntityInWindow(int begin, int end, vector<Entity>& src, vector<Entity>& dst) {
526 | 	for(int i=0;i<src.size();i++) {
527 | 		if(src[i].begin2==-1) {
528 | 			if(src[i].begin >= begin && src[i].end <= end)
529 | 				dst.push_back(src[i]);
530 | 		} else {
531 | 			if(src[i].begin >= begin && src[i].end2 <= end)
532 | 				dst.push_back(src[i]);
533 | 		}
534 | 
535 | 	}
536 | 
537 | 	return;
538 | }
539 | 
540 | // sentence spans from begin(include) to end(exclude), sorted because doc.entities are sorted
541 | void findEntityInSent(int begin, int end, const Document& doc, vector<Entity>& results) {
542 | 
543 | 	for(int i=0;i<doc.entities.size();i++) {
544 | 		if(doc.entities[i].begin2==-1) {
545 | 			if(doc.entities[i].begin >= begin && doc.entities[i].end <= end)
546 | 				results.push_back(doc.entities[i]);
547 | 		} else {
548 | 			if(doc.entities[i].begin >= begin && doc.entities[i].end2 <= end)
549 | 				results.push_back(doc.entities[i]);
550 | 		}
551 | 
552 | 	}
553 | 
554 | 	return;
555 | }
556 | 
557 | void findEntityInSent(int begin, int end, const vector<Entity>& source, vector<Entity>& results) {
558 | 
559 | 	for(int i=0;i<source.size();i++) {
560 | 		if(source[i].begin2==-1) {
561 | 			if(source[i].begin >= begin && source[i].end <= end)
562 | 				results.push_back(source[i]);
563 | 		} else {
564 | 			if(source[i].begin >= begin && source[i].end2 <= end)
565 | 				results.push_back(source[i]);
566 | 		}
567 | 
568 | 	}
569 | 
570 | 	return;
571 | }
572 | 
573 | void deleteEntity(vector<Entity>& entities, const Entity& target)
574 | {
575 | 	vector<Entity>::iterator iter = entities.begin();
576 | 	for(;iter!=entities.end();iter++) {
577 | 		if((*iter).equals(target)) {
578 | 			break;
579 | 		}
580 | 	}
581 | 	if(iter!=entities.end()) {
582 | 		entities.erase(iter);
583 | 	}
584 | }
585 | 
586 | int containsEntity(vector<Entity>& source, const Entity& target) {
587 | 
588 | 	for(int i=0;i<source.size();i++) {
589 | 		if(source[i].equals(target))
590 | 			return i;
591 | 
592 | 	}
593 | 
594 | 	return -1;
595 | }
596 | 
597 | int containsRelation(vector<Relation>& source, const Relation& target) {
598 | 
599 | 	for(int i=0;i<source.size();i++) {
600 | 		if(source[i].equals(target))
601 | 			return i;
602 | 
603 | 	}
604 | 
605 | 	return -1;
606 | }
607 | 
608 | int relationContainsEntity(vector<Relation>& source, const Entity& target) {
609 | 
610 | 	for(int i=0;i<source.size();i++) {
611 | 		if(source[i].bacteria.equals(target))
612 | 			return i;
613 | 		else if(source[i].location.equals(target))
614 | 			return i;
615 | 
616 | 	}
617 | 
618 | 	return -1;
619 | }
620 | 
621 | 
622 | bool isLoc(const Entity& bacteria, const Entity& location, const Document& doc) {
623 | 
624 | /*	for(int i=0;i<doc.relations.size();i++) {
625 | 		if(doc.relations[i].idBacteria == bacteria.id && doc.relations[i].idLocation == location.id)
626 | 			return true;
627 | 	}*/
628 | 	for(int i=0;i<doc.relations.size();i++) {
629 | 		if(doc.relations[i].bacteria.equals(bacteria) && doc.relations[i].location.equals(location))
630 | 				return true;
631 | 	}
632 | 
633 | 	return false;
634 | 
635 | }
636 | 
637 | bool isLoc(const string& idbacteria, const string& idlocation, const Document& doc) {
638 | 
639 | 	for(int i=0;i<doc.relations.size();i++) {
640 | 		if(doc.relations[i].idBacteria == idbacteria && doc.relations[i].idLocation == idlocation)
641 | 			return true;
642 | 	}
643 | 
644 | 	return false;
645 | 
646 | }
647 | 
648 | double precision(int correct, int predict) {
649 | 	return 1.0*correct/predict;
650 | }
651 | 
652 | double recall(int correct, int gold) {
653 | 	return 1.0*correct/gold;
654 | }
655 | 
656 | double f1(int correct, int gold, int predict) {
657 | 	double p = precision(correct, predict);
658 | 	double r = recall(correct, gold);
659 | 
660 | 	return 2*p*r/(p+r);
661 | }
662 | 
663 | 
664 | 
665 | 
666 | #endif /* UTILS_H_ */
667 | 


--------------------------------------------------------------------------------
/ade/Argument_helper.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | *
  3 | * Argument Helper
  4 | *
  5 | * Daniel Russel drussel@alumni.princeton.edu
  6 | * Stanford University
  7 | *
  8 | *
  9 | * This software is not subject to copyright protection and is in the
 10 | * public domain. Neither Stanford nor the author assume any
 11 | * responsibility whatsoever for its use by other parties, and makes no
 12 | * guarantees, expressed or implied, about its quality, reliability, or
 13 | * any other characteristic.
 14 | *
 15 | */
 16 | 
 17 | #ifndef _DSR_ARGS_H_
 18 | #define _DSR_ARGS_H_
 19 | #include <vector>
 20 | #include <map>
 21 | #include <list>
 22 | #include <string>
 23 | #include <iostream>
 24 | #include <cstdlib>
 25 | #include <cstdio>
 26 | //#include <limits>
 27 | #include <cassert>
 28 | #include <string.h>
 29 | 
 30 | 
 31 |  /*!
 32 |    
 33 |  \mainpage A Simple C++ Argument Parser
 34 | 
 35 |     This is a class to aid handling of command line arguments in a C++
 36 |     program. It follows (and enforces) the unsual conventions.
 37 | 
 38 |     New arguments are added by calling functions of the form of new_[optional_/named_]type.
 39 | 
 40 |     - type is the type of the value for the argument (int, double, string, vector of strings...)
 41 | 
 42 |     - optional means that the use doesn't have to supply it.
 43 | 
 44 |     - named means that it is identified by following an "-c" or
 45 |       "--long-name" identifier. All named arguments are optional.
 46 | 
 47 |     Unnamed arguments are expected to appear in order of addition on
 48 |     the command line. Named arguments can be passed in any order (and
 49 |     mixed with the unnamed arguments).
 50 | 
 51 |     The special argument "--" means that all remaining arguments are
 52 |     treated as unnamed (so you can pass file names that begin with -).
 53 | 
 54 |     When calling a new_foo function to create an argument the
 55 |     following can/must be passed in
 56 |     
 57 |     - For all arguments
 58 |      + The place to put the value.
 59 |      + A description of the value of the argument (i.e. it is a filename)
 60 |      + A description of the argument as a whole (i.e. it is the input file).
 61 | 
 62 |     - For named arguments
 63 |      + A character for the short name.
 64 |      + A string for the long name.
 65 | 
 66 |      When the program is called if "--help" is passed as an argument
 67 |      the useage information is printed and the program exits.
 68 | 
 69 |     There is always an implicit "-v" flag for verbose which sets the
 70 |     dsr::verbose variable and a "-V" which sets the VERBOSE variable.
 71 | 
 72 |     Any extra arguments or arguments with unexpected types are treated
 73 |     as errors and cause the program to abort. Extra arguments can be
 74 |     allowed for by adding a std::vector<std::string> to store them
 75 |     using the "set_string_vector" function. All extra (unnamed)
 76 |     arguments are placed there.
 77 | 
 78 |     This software is not subject to copyright protection and is in the
 79 |     public domain. Neither Stanford nor the author assume any
 80 |     responsibility whatsoever for its use by other parties, and makes no
 81 |     guarantees, expressed or implied, about its quality, reliability, or
 82 |     any other characteristic.
 83 | 
 84 |     An example using the class is:
 85 |     \include argument_helper_example.cc
 86 | 
 87 |   */
 88 | 
 89 | namespace dsr{
 90 |   extern bool verbose, VERBOSE;
 91 | 
 92 |   //! A helper class for parsing command line arguments.
 93 |   /*!
 94 |     This is the only class you need to look at in order to use it. 
 95 |   */
 96 |   class Argument_helper{
 97 |   private:
 98 |     class Argument_target;
 99 | 
100 |  
101 |     class FlagTarget;
102 |     class DoubleTarget;
103 |     class IntTarget;
104 |     class UIntTarget;
105 |     class StringTarget;
106 |     class CharTarget;
107 |     class StringVectorTarget;
108 | 
109 |   public:
110 |     Argument_helper();
111 |     //! Toggle a boolean
112 |     void new_flag(const char *key, const char *long_name, const char *description,bool &dest);
113 | 
114 |     //! add a string argument
115 |     void new_string( const char *arg_description, const char *description, std::string &dest);
116 |     //! add a string which must have a key.
117 |     void new_named_string(const char *key, const char *long_name,
118 | 			  const char *arg_description,
119 | 			  const char *description,  std::string &dest);
120 |     //! Add an optional string-- any extra arguments are put in these.
121 |     void new_optional_string( const char *arg_description, const char *description, std::string &dest);
122 | 
123 |     //! add an int
124 |     void new_int( const char *arg_description, const char *description, int &dest);
125 |     //! Add an int.
126 |     void new_named_int(const char *key, const char *long_name,const char *value_name,
127 | 		       const char *description,
128 | 		       int &dest);
129 |     //! Add an optional named int.
130 |     void new_optional_int(const char *value_name,
131 | 			  const char *description,
132 | 			  int &dest);
133 | 
134 |     //! Add a named double.
135 |     void new_double(const char *value_name,
136 | 		    const char *description,
137 | 		    double &dest);
138 | 
139 |     //! Add a named double.
140 |     void new_named_double(const char *key, const char *long_name,const char *value_name,
141 | 			  const char *description,
142 | 			  double &dest);
143 |     //! Add a named double.
144 |     void new_optional_double(const char *value_name,
145 | 			     const char *description,
146 | 			     double &dest);
147 | 
148 |     //! Add an char.
149 |     void new_char(const char *value_name,
150 | 				const char *description,
151 | 				char &dest);
152 |     //! Add an optional char.
153 |     void new_named_char(const char *key, const char *long_name,const char *value_name,
154 | 			   const char *description,
155 | 			   char &dest);
156 |     //! Add an named char.
157 |     void new_optional_char(const char *value_name,
158 | 			   const char *description,
159 | 			   char &dest);
160 | 
161 |     //! Add an unsigned int.
162 |     void new_unsigned_int(const char *value_name, const char *description,
163 | 			  unsigned int &dest);
164 |     //! Add an named unsigned int.
165 |     void new_optional_unsigned_int(const char *value_name, const char *description,
166 | 				unsigned int &dest);
167 |     //! Add an optional named unsigned int.
168 |     void new_named_unsigned_int(const char *key, const char *long_name,
169 | 				   const char *value_name, const char *description,
170 | 				   unsigned int &dest);
171 | 
172 | 
173 |     //! add a target which takes a list of strings
174 |     /*!
175 |       Only named makes sense as the string vector default handles unnamed and optional.
176 |     */
177 |     void new_named_string_vector(const char *key, const char *long_name,
178 | 				 const char *value_name, const char *description,
179 | 				 std::vector<std::string> &dest);
180 | 
181 |     //! add a vector of strings.
182 |     /*!  Any arguments which are not claimed by earlier unnamed
183 |       arguments or which are named are put here. This means you cannot
184 |       have a string vector followed by a string.
185 |     */
186 |     void set_string_vector(const char *arg_description, const char *description, std::vector<std::string> &dest);
187 | 
188 |     //! Set who wrote the program.
189 |     void set_author(const char *author);
190 | 
191 |     //! Set what the program does.
192 |     void set_description(const char *descr);
193 | 
194 |     //! Set what the version is.
195 |     void set_version(float v);
196 |     void set_version(const char *str);
197 | 
198 |     //! Set the name of the program.
199 |     void set_name(const char *name);
200 | 
201 |     //! Set when the program was built.
202 |     void set_build_date(const char *date);
203 | 
204 |     //! Process the list of arguments and parse them.
205 |     /*!
206 |       This returns true if all the required arguments are there. 
207 |     */
208 |     void process(int argc, const char **argv);
209 |     void process(int argc, char **argv){
210 |       process(argc, const_cast<const char **>(argv));
211 |     }
212 |     //! Write how to call the program.
213 |     void write_usage(std::ostream &out) const;
214 |     //! Write the values of all the possible arguments.
215 |     void write_values(std::ostream &out) const;
216 |     
217 |     ~Argument_helper();
218 |   protected:
219 |     typedef std::map<std::string, Argument_target*> SMap;
220 |     typedef std::map<std::string, Argument_target*> LMap;
221 |     typedef std::vector<Argument_target*> UVect;
222 |     // A map from short names to arguments.
223 |     SMap short_names_;
224 |     // A map from long names to arguments.
225 |     LMap long_names_;
226 |     std::string author_;
227 |     std::string name_;
228 |     std::string description_;
229 |     std::string date_;
230 |     float version_;
231 |     bool seen_end_named_;
232 |     // List of unnamed arguments
233 |     std::vector<Argument_target*> unnamed_arguments_;
234 |     std::vector<Argument_target*> optional_unnamed_arguments_;
235 |     std::vector<Argument_target*> all_arguments_;
236 |     std::string extra_arguments_descr_;
237 |     std::string extra_arguments_arg_descr_;
238 |     std::vector<std::string> *extra_arguments_;
239 |     std::vector<Argument_target*>::iterator current_unnamed_;
240 |     std::vector<Argument_target*>::iterator current_optional_unnamed_;
241 |     void new_argument_target(Argument_target*);
242 |     void handle_error() const;
243 |   private:
244 |     Argument_helper(const Argument_helper &){};
245 |     const Argument_helper& operator=(const Argument_helper &){return *this;}
246 |   };
247 | 
248 | 
249 | 
250 | 	
251 |   bool verbose=false, VERBOSE=false;
252 | 
253 | 
254 |   //////////////////////////////////////////////// Argument Targets
255 | 
256 |   // This is a base class for representing one argument value.
257 |   /* 
258 |      This is inherited by many classes and which represent the different types. 
259 |   */
260 |   class Argument_helper::Argument_target {
261 |   public:
262 |     std::string key;
263 |     std::string long_name;
264 |     std::string description;
265 |     std::string arg_description;
266 |    
267 |     Argument_target(const std::string& k, const std::string& lname,
268 | 		    const std::string& descr,
269 | 		    const std::string& arg_descr) {
270 |       key=k;
271 |       long_name=lname;
272 |       description=descr;
273 |       arg_description=arg_descr;
274 |     }
275 |     Argument_target(const std::string& descr,
276 | 		    const std::string& arg_descr) {
277 |       key="";
278 |       long_name="";
279 |       description=descr;
280 |       arg_description=arg_descr;
281 |     }
282 |     virtual bool process(int &, const char **&)=0;
283 |     virtual void write_name(std::ostream &out) const;
284 |     virtual void write_value(std::ostream &out) const=0;
285 |     virtual void write_usage(std::ostream &out) const;
286 |     virtual ~Argument_target(){}
287 |   };
288 | 
289 |   void Argument_helper::Argument_target::write_name(std::ostream &out) const {
290 |     if (key != "") out << '-' << key;
291 |     else if (!long_name.empty()) out << "--" << long_name;
292 |     else out << arg_description;
293 |   }
294 | 
295 |   
296 |   void Argument_helper::Argument_target::write_usage(std::ostream &out) const {
297 |     if (key != "") {
298 |       out << '-' << key;
299 |       out << "/--" << long_name;
300 |     }
301 |     out << ' ' << arg_description;
302 |     out << "\t" << description;
303 |     out << " Value: ";
304 |     write_value(out);
305 |     out << std::endl;
306 |   }
307 | 
308 |   class Argument_helper::FlagTarget: public Argument_helper::Argument_target{
309 |   public:
310 |     bool &val;
311 |     FlagTarget(const char *k, const char *lname,
312 | 	       const char *descr,
313 | 	       bool &b): Argument_target(std::string(k), std::string(lname), std::string(descr),
314 | 					 std::string()),  val(b){}
315 |     virtual bool process(int &, const char **&){
316 |       val= !val;
317 |       return true;
318 |     }
319 |     virtual void write_value(std::ostream &out) const {
320 |       out << val;
321 |     }
322 | 
323 |     virtual void write_usage(std::ostream &out) const {
324 |       if (key != "") {
325 | 	out << '-' << key;
326 | 	out << "/--" << long_name;
327 |       }
328 |       out << "\t" << description;
329 |       out << " Value: ";
330 |       write_value(out);
331 |       out << std::endl;
332 |     }
333 |     virtual ~FlagTarget(){}
334 |   };
335 | 
336 |   class Argument_helper::DoubleTarget: public Argument_target{
337 |   public:
338 |     double &val;
339 |     DoubleTarget(const char *k, const char *lname,
340 | 		 const char *arg_descr, 
341 | 		 const char *descr, double &b): Argument_target(std::string(k), std::string(lname),
342 | 								    std::string(descr),
343 | 								    std::string(arg_descr)),  val(b){}
344 |     DoubleTarget(const char *arg_descr, 
345 | 		 const char *descr, double &b): Argument_target(std::string(descr),
346 | 								    std::string(arg_descr)),  val(b){}
347 |     virtual bool process(int &argc, const char **&argv){
348 |       if (argc==0){
349 | 	std::cerr << "Missing value for argument." << std::endl;
350 | 	return false;
351 |       }
352 |       if (sscanf(argv[0], "%le", &val) ==1){
353 | 	--argc;
354 | 	++argv;
355 | 	return true;
356 |       }  else {
357 | 	std::cerr << "Double not found at " << argv[0] << std::endl;
358 | 	return false;
359 |       }
360 |     }
361 |     virtual void write_value(std::ostream &out) const {
362 |       out << val;
363 |     }
364 |     virtual ~DoubleTarget(){}
365 |   };
366 | 
367 |   class Argument_helper::IntTarget: public Argument_target{
368 |   public:
369 |     int &val;
370 |     IntTarget(const char *arg_descr, 
371 | 	      const char *descr, int &b): Argument_target(std::string(descr), std::string(arg_descr)),
372 | 					      val(b){}
373 |     IntTarget(const char *k, const char *lname,
374 | 	      const char *arg_descr, 
375 | 	      const char *descr, int &b): Argument_target(std::string(k), std::string(lname),
376 | 							      std::string(descr),
377 | 							      std::string(arg_descr)), 
378 | 					      val(b){}
379 |     virtual bool process(int &argc, const char **&argv){
380 |       if (argc==0){
381 | 	std::cerr << "Missing value for argument." << std::endl;
382 | 	return false;
383 |       }
384 |       if (sscanf(argv[0], "%d", &val) ==1){
385 | 	--argc;
386 | 	++argv;
387 | 	return true;
388 |       }  else {
389 | 	std::cerr << "Integer not found at " << argv[0] << std::endl;
390 | 	return false;
391 |       }
392 |     }
393 |     virtual void write_value(std::ostream &out) const {
394 |       out << val;
395 |     }
396 |     virtual ~IntTarget(){}
397 |   };
398 | 
399 |   class Argument_helper::UIntTarget: public Argument_target{
400 |   public:
401 |     unsigned int &val;
402 |     UIntTarget(const char *arg_descr, 
403 | 	       const char *descr, unsigned int &b): Argument_target(std::string(descr), std::string(arg_descr)),
404 | 					       val(b){}
405 |     UIntTarget(const char *k, const char *lname,
406 | 	       const char *arg_descr, 
407 | 	       const char *descr, unsigned int &b): Argument_target(std::string(k), std::string(lname),
408 | 							       std::string(descr),
409 | 							       std::string(arg_descr)), 
410 | 					       val(b){}
411 |     virtual bool process(int &argc, const char **&argv){
412 |       if (argc==0){
413 | 	std::cerr << "Missing value for argument." << std::endl;
414 | 	return false;
415 |       }
416 |       if (sscanf(argv[0], "%ud", &val) ==1){
417 | 	--argc;
418 | 	++argv;
419 | 	return true;
420 |       } else {
421 | 	std::cerr << "Unsigned integer not found at " << argv[0] << std::endl;
422 | 	return false;
423 |       }
424 |     }
425 |     virtual void write_value(std::ostream &out) const {
426 |       out << val;
427 |     }
428 |     virtual ~UIntTarget(){}
429 |   };
430 |  
431 | 
432 |   class Argument_helper::CharTarget: public Argument_target{
433 |   public:
434 |     char &val;
435 |     CharTarget(const char *k, const char *lname,
436 | 	       const char *arg_descr, 
437 | 	       const char *descr, char &b): Argument_target(std::string(k), std::string(lname),
438 | 								std::string(descr),
439 | 								std::string(arg_descr)),  val(b){}
440 |     CharTarget(const char *arg_descr, 
441 | 	       const char *descr, char &b): Argument_target(std::string(descr),
442 | 								std::string(arg_descr)),  val(b){}
443 |     virtual bool process(int &argc, const char **&argv){
444 |       if (argc==0){
445 | 	std::cerr << "Missing value for argument." << std::endl;
446 | 	return false;
447 |       }
448 |       if (sscanf(argv[0], "%c", &val) ==1){
449 | 	--argc;
450 | 	++argv;
451 | 	return true;
452 |       }  else {
453 | 	std::cerr << "Character not found at " << argv[0] << std::endl;
454 | 	return false;
455 |       }
456 |     }
457 |     virtual void write_value(std::ostream &out) const {
458 |       out << val;
459 |     }
460 |     virtual ~CharTarget(){}
461 |   };
462 | 
463 | 
464 |   class Argument_helper::StringTarget: public Argument_target{
465 |   public:
466 |     std::string &val;
467 |     StringTarget(const char *arg_descr, 
468 | 		 const char *descr, std::string &b): Argument_target(std::string(descr),  std::string(arg_descr)),
469 | 							 val(b){}
470 | 
471 |     StringTarget(const char *k, const char *lname, const char *arg_descr,
472 | 		 const char *descr, std::string &b): Argument_target(std::string(k), std::string(lname),
473 | 		     std::string(descr), std::string(arg_descr)),
474 | 							 val(b){}
475 | 
476 |     virtual bool process(int &argc, const char **&argv){
477 |       if (argc==0){
478 | 	std::cerr << "Missing string argument." << std::endl;
479 | 	return false;
480 |       }
481 |       val= argv[0];
482 |       --argc;
483 |       ++argv;
484 |       return true;
485 |     }
486 |     virtual void write_value(std::ostream &out) const {
487 |       out << val;
488 |     }
489 |     virtual ~StringTarget(){}
490 |   };
491 | 
492 | 
493 |   class Argument_helper::StringVectorTarget: public Argument_target{
494 |   public:
495 |     std::vector<std::string> &val;
496 | 
497 |     StringVectorTarget(const char *k, const char *lname, const char *arg_descr,
498 | 		 const char *descr, std::vector<std::string> &b): Argument_target(std::string(k), std::string(lname),
499 | 		     std::string(descr), std::string(arg_descr)),
500 | 						     val(b){}
501 | 
502 |     virtual bool process(int &argc, const char **&argv){
503 |       while (argc >0 && argv[0][0] != '-'){
504 | 	val.push_back(argv[0]);
505 | 	--argc;
506 | 	++argv;
507 |       }
508 |       return true;
509 |     }
510 |     virtual void write_value(std::ostream &out) const {
511 |       for (unsigned int i=0; i< val.size(); ++i){
512 | 	out << val[i] << " ";
513 |       }
514 |     }
515 |     virtual ~StringVectorTarget(){}
516 |   };
517 | 
518 | 
519 |   //////////////////////////////////////////////// Argument_helper functions
520 | 
521 | 
522 |   Argument_helper::Argument_helper(){
523 |     author_="a programmer";
524 |     description_= "This program produces output.";
525 |     date_= "some day a long, long time ago.";
526 |     version_=-1;
527 |     extra_arguments_=NULL;
528 |     seen_end_named_=false;
529 |     new_flag("v", "verbose", "Whether to print extra information", verbose);
530 |     new_flag("V", "VERBOSE", "Whether to print lots of extra information", VERBOSE);
531 |   }
532 | 
533 | 
534 | 
535 |   void Argument_helper::set_string_vector(const char *arg_description, 
536 | 					  const char *description, 
537 | 					  std::vector<std::string> &dest){
538 |     assert(extra_arguments_==NULL);
539 |     extra_arguments_descr_= description;
540 |     extra_arguments_arg_descr_= arg_description;
541 |     extra_arguments_= &dest;
542 |   }
543 | 
544 |   void Argument_helper::set_author(const char *author){
545 |     author_=author;
546 |   }
547 | 
548 |   void Argument_helper::set_description(const char *descr){
549 |     description_= descr;
550 |   }
551 | 
552 |   void Argument_helper::set_name(const char *descr){
553 |     name_= descr;
554 |   }
555 | 
556 |   void Argument_helper::set_version(float v){
557 |     version_=v;
558 |   }
559 | 
560 |   void Argument_helper::set_version(const char *s){
561 |     version_=atof(s);
562 |   }
563 | 
564 |   void  Argument_helper::set_build_date(const char *date){
565 |     date_=date;
566 |   }
567 |   
568 |   void Argument_helper::new_argument_target(Argument_target *t) {
569 |     assert(t!= NULL);
570 |     if (t->key != ""){
571 |       if (short_names_.find(t->key) != short_names_.end()){
572 | 	std::cerr << "Two arguments are defined with the same string key, namely" << std::endl;
573 | 	short_names_[t->key]->write_usage(std::cerr);
574 | 	std::cerr << "\n and \n";
575 | 	t->write_usage(std::cerr);
576 | 	std::cerr << std::endl;
577 |       }
578 |       short_names_[t->key]= t;
579 |     } 
580 |     if (!t->long_name.empty()){
581 |       if (long_names_.find(t->long_name) != long_names_.end()){
582 | 	std::cerr << "Two arguments are defined with the same long key, namely" << std::endl;
583 | 	long_names_[t->long_name]->write_usage(std::cerr);
584 | 	std::cerr << "\n and \n";
585 | 	t->write_usage(std::cerr);
586 | 	std::cerr << std::endl;
587 |       }
588 |       long_names_[t->long_name]= t;
589 |     }
590 |     all_arguments_.push_back(t);
591 |   }
592 |   
593 |   void Argument_helper::new_flag(const char *key, const char *long_name, const char *description,bool &dest){
594 |     Argument_target *t= new FlagTarget(key, long_name, description, dest);
595 |     new_argument_target(t);
596 |   };
597 | 
598 | 
599 | 
600 |   void Argument_helper::new_string(const char *arg_description, const char *description,
601 | 				   std::string &dest){
602 |     Argument_target *t= new StringTarget(arg_description, description, dest);
603 |     unnamed_arguments_.push_back(t);
604 |     all_arguments_.push_back(t);
605 |   };
606 |   void Argument_helper::new_optional_string(const char *arg_description, const char *description,
607 | 					    std::string &dest){
608 |     Argument_target *t= new StringTarget(arg_description, description, dest);
609 |     optional_unnamed_arguments_.push_back(t);
610 |   };
611 |   void Argument_helper::new_named_string(const char *key, const char *long_name,
612 | 					 const char *arg_description, const char *description,
613 | 					 std::string &dest){
614 |     Argument_target *t= new StringTarget(key, long_name, arg_description, description, dest);
615 |     new_argument_target(t);
616 |   };
617 | 
618 | 
619 |   void Argument_helper::new_named_string_vector(const char *key, const char *long_name,
620 | 					 const char *arg_description, const char *description,
621 | 					 std::vector<std::string> &dest){
622 |     Argument_target *t= new StringVectorTarget(key, long_name, arg_description, description, dest);
623 |     new_argument_target(t);
624 |   };
625 | 
626 | 
627 | 
628 |   void Argument_helper::new_int(const char *arg_description, const char *description,
629 | 				   int &dest){
630 |     Argument_target *t= new IntTarget(arg_description, description, dest);
631 |     unnamed_arguments_.push_back(t);
632 |     all_arguments_.push_back(t);
633 |   };
634 |   void Argument_helper::new_optional_int(const char *arg_description, const char *description,
635 | 					    int &dest){
636 |     Argument_target *t= new IntTarget(arg_description, description, dest);
637 |     optional_unnamed_arguments_.push_back(t);
638 |   };
639 |   void Argument_helper::new_named_int(const char *key, const char *long_name,
640 | 					 const char *arg_description, const char *description,
641 | 					 int &dest){
642 |     Argument_target *t= new IntTarget(key, long_name, arg_description, description, dest);
643 |     new_argument_target(t);
644 |   };
645 | 
646 |   void Argument_helper::new_unsigned_int(const char *arg_description, const char *description,
647 | 					unsigned int &dest){
648 |     Argument_target *t= new UIntTarget(arg_description, description, dest);
649 |     unnamed_arguments_.push_back(t);
650 |     all_arguments_.push_back(t);
651 |   };
652 |   void Argument_helper::new_optional_unsigned_int(const char *arg_description, const char *description,
653 | 					    unsigned int &dest){
654 |     Argument_target *t= new UIntTarget(arg_description, description, dest);
655 |     optional_unnamed_arguments_.push_back(t);
656 |   };
657 |   void Argument_helper::new_named_unsigned_int(const char *key, const char *long_name,
658 | 					       const char *arg_description, const char *description,
659 | 					       unsigned int &dest){
660 |     Argument_target *t= new UIntTarget(key, long_name, arg_description, description, dest);
661 |     new_argument_target(t);
662 |   };
663 | 
664 | 
665 |   void Argument_helper::new_double(const char *arg_description, const char *description,
666 | 				   double &dest){
667 |     Argument_target *t= new DoubleTarget(arg_description, description, dest);
668 |     unnamed_arguments_.push_back(t);
669 |     all_arguments_.push_back(t);
670 |   };
671 |   void Argument_helper::new_optional_double(const char *arg_description, const char *description,
672 | 					    double &dest){
673 |     Argument_target *t= new DoubleTarget(arg_description, description, dest);
674 |     optional_unnamed_arguments_.push_back(t);
675 |   };
676 |   void Argument_helper::new_named_double(const char *key, const char *long_name,
677 | 					 const char *arg_description, const char *description,
678 | 					 double &dest){
679 |     Argument_target *t= new DoubleTarget(key, long_name, arg_description, description, dest);
680 |     new_argument_target(t);
681 |   };
682 | 
683 |   void Argument_helper::new_char(const char *arg_description, const char *description,
684 | 				 char &dest){
685 |     Argument_target *t= new CharTarget(arg_description, description, dest);
686 |     unnamed_arguments_.push_back(t);
687 |     all_arguments_.push_back(t);
688 |   };
689 |   void Argument_helper::new_optional_char(const char *arg_description, const char *description,
690 | 					    char &dest){
691 |     Argument_target *t= new CharTarget(arg_description, description, dest);
692 |     optional_unnamed_arguments_.push_back(t);
693 |   };
694 |   void Argument_helper::new_named_char(const char *key, const char *long_name,
695 | 					 const char *arg_description, const char *description,
696 | 					 char &dest){
697 |     Argument_target *t= new CharTarget(key, long_name, arg_description, description, dest);
698 |     new_argument_target(t);
699 |   };
700 | 
701 | 
702 | 
703 |   void Argument_helper::write_usage(std::ostream &out) const {
704 |     out << name_ << " version " << version_ << ", by " << author_ << std::endl;
705 |     out << description_ << std::endl;
706 |     out << "Compiled on " << date_ << std::endl << std::endl;
707 |     out << "Usage: " << name_  << " ";
708 |     for (UVect::const_iterator it= unnamed_arguments_.begin(); it != unnamed_arguments_.end(); ++it){
709 |       (*it)->write_name(out);
710 |       out << " ";
711 |     }
712 |     for (UVect::const_iterator it= optional_unnamed_arguments_.begin(); 
713 | 	 it != optional_unnamed_arguments_.end(); ++it){
714 |       out << "[";
715 |       (*it)->write_name(out);
716 |       out << "] ";
717 |     }
718 |     if (extra_arguments_ != NULL) {
719 |       out << "[" << extra_arguments_arg_descr_ << "]";
720 |     }    
721 | 
722 |     out << std::endl << std::endl;
723 |     out << "All arguments:\n";
724 |     for (UVect::const_iterator it= unnamed_arguments_.begin(); it != unnamed_arguments_.end(); ++it){
725 |       (*it)->write_usage(out);
726 |     }
727 |     for (UVect::const_iterator it= optional_unnamed_arguments_.begin(); 
728 | 	 it != optional_unnamed_arguments_.end(); ++it){
729 |       (*it)->write_usage(out);
730 |     }
731 | 
732 |    if (!extra_arguments_arg_descr_.empty()) {
733 |      out << extra_arguments_arg_descr_ << ": " << extra_arguments_descr_ << std::endl;
734 |    }
735 |     for (SMap::const_iterator it= short_names_.begin(); it != short_names_.end(); ++it){
736 |       (it->second)->write_usage(out);
737 |     }
738 |   }
739 | 
740 | 
741 | 
742 |   void Argument_helper::write_values(std::ostream &out) const {
743 |     for (UVect::const_iterator it= unnamed_arguments_.begin(); it != unnamed_arguments_.end(); ++it){
744 |       out << (*it)->description;
745 |       out << ": ";
746 |       (*it)->write_value(out);
747 |       out << std::endl;
748 |     }
749 |     for (UVect::const_iterator it= optional_unnamed_arguments_.begin(); 
750 | 	 it != optional_unnamed_arguments_.end(); ++it){
751 |       out << (*it)->description;
752 |       out << ": ";
753 |       (*it)->write_value(out);
754 |       out << std::endl;
755 |     }
756 |     if (extra_arguments_!=NULL){
757 |       for (std::vector<std::string>::const_iterator it= extra_arguments_->begin(); 
758 | 	   it != extra_arguments_->end(); ++it){
759 | 	out << *it << " ";
760 |       }
761 |     }
762 | 
763 |     for (SMap::const_iterator it= short_names_.begin(); it != short_names_.end(); ++it){
764 |       out << it->second->description;
765 |       out << ": ";
766 |       it->second->write_value(out);
767 |       out << std::endl;
768 |     }
769 |   }
770 | 
771 |   Argument_helper::~Argument_helper(){
772 |     for (std::vector<Argument_target*>::iterator it= all_arguments_.begin();
773 | 	 it != all_arguments_.end(); ++it){
774 |       delete *it;
775 |     }
776 |   }
777 | 
778 | 
779 |   void Argument_helper::process(int argc,  const char **argv){
780 |     name_= argv[0];
781 |     ++argv;
782 |     --argc;
783 | 
784 |     current_unnamed_= unnamed_arguments_.begin();
785 |     current_optional_unnamed_= optional_unnamed_arguments_.begin();
786 |     
787 |     for ( int i=0; i< argc; ++i){
788 |       if (strcmp(argv[i], "--help") == 0){
789 | 	write_usage(std::cout);
790 | 	exit(0);
791 |       }
792 |     }
793 | 
794 |     while (argc != 0){
795 | 
796 |       const char* cur_arg= argv[0];
797 |       if (cur_arg[0]=='-' && !seen_end_named_){
798 | 	--argc; ++argv;
799 | 	if (cur_arg[1]=='-'){
800 | 	  if (cur_arg[2] == '\0') {
801 | 	    //std::cout << "Ending flags " << std::endl;
802 | 	    seen_end_named_=true;
803 | 	  } else {
804 | 	    // long argument
805 | 	    LMap::iterator f= long_names_.find(cur_arg+2);
806 | 	    if ( f != long_names_.end()){
807 | 	      if (!f->second->process(argc, argv)) {
808 | 		handle_error();
809 | 	      }
810 | 	    } else {
811 | 	      std::cerr<< "Invalid long argument "<< cur_arg << ".\n";
812 | 	      handle_error();
813 | 	    }
814 | 	  }
815 | 	} else {
816 | 	  if (cur_arg[1]=='\0') {
817 | 	    std::cerr << "Invalid argument " << cur_arg << ".\n";
818 | 	    handle_error();
819 | 	  }
820 | 	  SMap::iterator f= short_names_.find(cur_arg+1);
821 | 	  if ( f != short_names_.end()){
822 | 	    if (!f->second->process(argc, argv)) {
823 | 	      handle_error();
824 | 	    }
825 | 	  } else {
826 | 	    std::cerr<< "Invalid short argument "<< cur_arg << ".\n";
827 | 	    handle_error();
828 | 	  }
829 |  	}
830 |       } else {
831 | 	if (current_unnamed_ != unnamed_arguments_.end()){
832 | 	  Argument_target *t= *current_unnamed_;
833 | 	  t->process(argc, argv);
834 | 	  ++current_unnamed_;
835 | 	} else if (current_optional_unnamed_ != optional_unnamed_arguments_.end()){
836 | 	  Argument_target *t= *current_optional_unnamed_;
837 | 	  t->process(argc, argv);
838 | 	  ++current_optional_unnamed_;
839 | 	} else if (extra_arguments_!= NULL){
840 | 	  extra_arguments_->push_back(cur_arg);
841 | 	  --argc;
842 | 	  ++argv;
843 | 	} else {
844 | 	  std::cerr << "Invalid extra argument " << argv[0] << std::endl;
845 | 	  handle_error();
846 | 	}
847 |       }
848 |     }
849 | 
850 |     if (current_unnamed_ != unnamed_arguments_.end()){
851 |       std::cerr << "Missing required arguments:" << std::endl;
852 |       for (; current_unnamed_ != unnamed_arguments_.end(); ++current_unnamed_){
853 | 	(*current_unnamed_)->write_name(std::cerr);
854 | 	std::cerr << std::endl;
855 |       }
856 |       std::cerr << std::endl;
857 |       handle_error();
858 |     }
859 | 
860 |     if (VERBOSE) verbose=true;
861 |   }
862 | 
863 |   void Argument_helper::handle_error() const {
864 |     write_usage(std::cerr);
865 |     exit(1);
866 |   }
867 |   
868 | }
869 | 
870 | 
871 | 
872 | 
873 | 
874 | #endif
875 | 


--------------------------------------------------------------------------------
/bb3/Argument_helper.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | *
  3 | * Argument Helper
  4 | *
  5 | * Daniel Russel drussel@alumni.princeton.edu
  6 | * Stanford University
  7 | *
  8 | *
  9 | * This software is not subject to copyright protection and is in the
 10 | * public domain. Neither Stanford nor the author assume any
 11 | * responsibility whatsoever for its use by other parties, and makes no
 12 | * guarantees, expressed or implied, about its quality, reliability, or
 13 | * any other characteristic.
 14 | *
 15 | */
 16 | 
 17 | #ifndef _DSR_ARGS_H_
 18 | #define _DSR_ARGS_H_
 19 | #include <vector>
 20 | #include <map>
 21 | #include <list>
 22 | #include <string>
 23 | #include <iostream>
 24 | #include <cstdlib>
 25 | #include <cstdio>
 26 | //#include <limits>
 27 | #include <cassert>
 28 | #include <string.h>
 29 | 
 30 | 
 31 |  /*!
 32 |    
 33 |  \mainpage A Simple C++ Argument Parser
 34 | 
 35 |     This is a class to aid handling of command line arguments in a C++
 36 |     program. It follows (and enforces) the unsual conventions.
 37 | 
 38 |     New arguments are added by calling functions of the form of new_[optional_/named_]type.
 39 | 
 40 |     - type is the type of the value for the argument (int, double, string, vector of strings...)
 41 | 
 42 |     - optional means that the use doesn't have to supply it.
 43 | 
 44 |     - named means that it is identified by following an "-c" or
 45 |       "--long-name" identifier. All named arguments are optional.
 46 | 
 47 |     Unnamed arguments are expected to appear in order of addition on
 48 |     the command line. Named arguments can be passed in any order (and
 49 |     mixed with the unnamed arguments).
 50 | 
 51 |     The special argument "--" means that all remaining arguments are
 52 |     treated as unnamed (so you can pass file names that begin with -).
 53 | 
 54 |     When calling a new_foo function to create an argument the
 55 |     following can/must be passed in
 56 |     
 57 |     - For all arguments
 58 |      + The place to put the value.
 59 |      + A description of the value of the argument (i.e. it is a filename)
 60 |      + A description of the argument as a whole (i.e. it is the input file).
 61 | 
 62 |     - For named arguments
 63 |      + A character for the short name.
 64 |      + A string for the long name.
 65 | 
 66 |      When the program is called if "--help" is passed as an argument
 67 |      the useage information is printed and the program exits.
 68 | 
 69 |     There is always an implicit "-v" flag for verbose which sets the
 70 |     dsr::verbose variable and a "-V" which sets the VERBOSE variable.
 71 | 
 72 |     Any extra arguments or arguments with unexpected types are treated
 73 |     as errors and cause the program to abort. Extra arguments can be
 74 |     allowed for by adding a std::vector<std::string> to store them
 75 |     using the "set_string_vector" function. All extra (unnamed)
 76 |     arguments are placed there.
 77 | 
 78 |     This software is not subject to copyright protection and is in the
 79 |     public domain. Neither Stanford nor the author assume any
 80 |     responsibility whatsoever for its use by other parties, and makes no
 81 |     guarantees, expressed or implied, about its quality, reliability, or
 82 |     any other characteristic.
 83 | 
 84 |     An example using the class is:
 85 |     \include argument_helper_example.cc
 86 | 
 87 |   */
 88 | 
 89 | namespace dsr{
 90 |   extern bool verbose, VERBOSE;
 91 | 
 92 |   //! A helper class for parsing command line arguments.
 93 |   /*!
 94 |     This is the only class you need to look at in order to use it. 
 95 |   */
 96 |   class Argument_helper{
 97 |   private:
 98 |     class Argument_target;
 99 | 
100 |  
101 |     class FlagTarget;
102 |     class DoubleTarget;
103 |     class IntTarget;
104 |     class UIntTarget;
105 |     class StringTarget;
106 |     class CharTarget;
107 |     class StringVectorTarget;
108 | 
109 |   public:
110 |     Argument_helper();
111 |     //! Toggle a boolean
112 |     void new_flag(const char *key, const char *long_name, const char *description,bool &dest);
113 | 
114 |     //! add a string argument
115 |     void new_string( const char *arg_description, const char *description, std::string &dest);
116 |     //! add a string which must have a key.
117 |     void new_named_string(const char *key, const char *long_name,
118 | 			  const char *arg_description,
119 | 			  const char *description,  std::string &dest);
120 |     //! Add an optional string-- any extra arguments are put in these.
121 |     void new_optional_string( const char *arg_description, const char *description, std::string &dest);
122 | 
123 |     //! add an int
124 |     void new_int( const char *arg_description, const char *description, int &dest);
125 |     //! Add an int.
126 |     void new_named_int(const char *key, const char *long_name,const char *value_name,
127 | 		       const char *description,
128 | 		       int &dest);
129 |     //! Add an optional named int.
130 |     void new_optional_int(const char *value_name,
131 | 			  const char *description,
132 | 			  int &dest);
133 | 
134 |     //! Add a named double.
135 |     void new_double(const char *value_name,
136 | 		    const char *description,
137 | 		    double &dest);
138 | 
139 |     //! Add a named double.
140 |     void new_named_double(const char *key, const char *long_name,const char *value_name,
141 | 			  const char *description,
142 | 			  double &dest);
143 |     //! Add a named double.
144 |     void new_optional_double(const char *value_name,
145 | 			     const char *description,
146 | 			     double &dest);
147 | 
148 |     //! Add an char.
149 |     void new_char(const char *value_name,
150 | 				const char *description,
151 | 				char &dest);
152 |     //! Add an optional char.
153 |     void new_named_char(const char *key, const char *long_name,const char *value_name,
154 | 			   const char *description,
155 | 			   char &dest);
156 |     //! Add an named char.
157 |     void new_optional_char(const char *value_name,
158 | 			   const char *description,
159 | 			   char &dest);
160 | 
161 |     //! Add an unsigned int.
162 |     void new_unsigned_int(const char *value_name, const char *description,
163 | 			  unsigned int &dest);
164 |     //! Add an named unsigned int.
165 |     void new_optional_unsigned_int(const char *value_name, const char *description,
166 | 				unsigned int &dest);
167 |     //! Add an optional named unsigned int.
168 |     void new_named_unsigned_int(const char *key, const char *long_name,
169 | 				   const char *value_name, const char *description,
170 | 				   unsigned int &dest);
171 | 
172 | 
173 |     //! add a target which takes a list of strings
174 |     /*!
175 |       Only named makes sense as the string vector default handles unnamed and optional.
176 |     */
177 |     void new_named_string_vector(const char *key, const char *long_name,
178 | 				 const char *value_name, const char *description,
179 | 				 std::vector<std::string> &dest);
180 | 
181 |     //! add a vector of strings.
182 |     /*!  Any arguments which are not claimed by earlier unnamed
183 |       arguments or which are named are put here. This means you cannot
184 |       have a string vector followed by a string.
185 |     */
186 |     void set_string_vector(const char *arg_description, const char *description, std::vector<std::string> &dest);
187 | 
188 |     //! Set who wrote the program.
189 |     void set_author(const char *author);
190 | 
191 |     //! Set what the program does.
192 |     void set_description(const char *descr);
193 | 
194 |     //! Set what the version is.
195 |     void set_version(float v);
196 |     void set_version(const char *str);
197 | 
198 |     //! Set the name of the program.
199 |     void set_name(const char *name);
200 | 
201 |     //! Set when the program was built.
202 |     void set_build_date(const char *date);
203 | 
204 |     //! Process the list of arguments and parse them.
205 |     /*!
206 |       This returns true if all the required arguments are there. 
207 |     */
208 |     void process(int argc, const char **argv);
209 |     void process(int argc, char **argv){
210 |       process(argc, const_cast<const char **>(argv));
211 |     }
212 |     //! Write how to call the program.
213 |     void write_usage(std::ostream &out) const;
214 |     //! Write the values of all the possible arguments.
215 |     void write_values(std::ostream &out) const;
216 |     
217 |     ~Argument_helper();
218 |   protected:
219 |     typedef std::map<std::string, Argument_target*> SMap;
220 |     typedef std::map<std::string, Argument_target*> LMap;
221 |     typedef std::vector<Argument_target*> UVect;
222 |     // A map from short names to arguments.
223 |     SMap short_names_;
224 |     // A map from long names to arguments.
225 |     LMap long_names_;
226 |     std::string author_;
227 |     std::string name_;
228 |     std::string description_;
229 |     std::string date_;
230 |     float version_;
231 |     bool seen_end_named_;
232 |     // List of unnamed arguments
233 |     std::vector<Argument_target*> unnamed_arguments_;
234 |     std::vector<Argument_target*> optional_unnamed_arguments_;
235 |     std::vector<Argument_target*> all_arguments_;
236 |     std::string extra_arguments_descr_;
237 |     std::string extra_arguments_arg_descr_;
238 |     std::vector<std::string> *extra_arguments_;
239 |     std::vector<Argument_target*>::iterator current_unnamed_;
240 |     std::vector<Argument_target*>::iterator current_optional_unnamed_;
241 |     void new_argument_target(Argument_target*);
242 |     void handle_error() const;
243 |   private:
244 |     Argument_helper(const Argument_helper &){};
245 |     const Argument_helper& operator=(const Argument_helper &){return *this;}
246 |   };
247 | 
248 | 
249 | 
250 | 	
251 |   bool verbose=false, VERBOSE=false;
252 | 
253 | 
254 |   //////////////////////////////////////////////// Argument Targets
255 | 
256 |   // This is a base class for representing one argument value.
257 |   /* 
258 |      This is inherited by many classes and which represent the different types. 
259 |   */
260 |   class Argument_helper::Argument_target {
261 |   public:
262 |     std::string key;
263 |     std::string long_name;
264 |     std::string description;
265 |     std::string arg_description;
266 |    
267 |     Argument_target(const std::string& k, const std::string& lname,
268 | 		    const std::string& descr,
269 | 		    const std::string& arg_descr) {
270 |       key=k;
271 |       long_name=lname;
272 |       description=descr;
273 |       arg_description=arg_descr;
274 |     }
275 |     Argument_target(const std::string& descr,
276 | 		    const std::string& arg_descr) {
277 |       key="";
278 |       long_name="";
279 |       description=descr;
280 |       arg_description=arg_descr;
281 |     }
282 |     virtual bool process(int &, const char **&)=0;
283 |     virtual void write_name(std::ostream &out) const;
284 |     virtual void write_value(std::ostream &out) const=0;
285 |     virtual void write_usage(std::ostream &out) const;
286 |     virtual ~Argument_target(){}
287 |   };
288 | 
289 |   void Argument_helper::Argument_target::write_name(std::ostream &out) const {
290 |     if (key != "") out << '-' << key;
291 |     else if (!long_name.empty()) out << "--" << long_name;
292 |     else out << arg_description;
293 |   }
294 | 
295 |   
296 |   void Argument_helper::Argument_target::write_usage(std::ostream &out) const {
297 |     if (key != "") {
298 |       out << '-' << key;
299 |       out << "/--" << long_name;
300 |     }
301 |     out << ' ' << arg_description;
302 |     out << "\t" << description;
303 |     out << " Value: ";
304 |     write_value(out);
305 |     out << std::endl;
306 |   }
307 | 
308 |   class Argument_helper::FlagTarget: public Argument_helper::Argument_target{
309 |   public:
310 |     bool &val;
311 |     FlagTarget(const char *k, const char *lname,
312 | 	       const char *descr,
313 | 	       bool &b): Argument_target(std::string(k), std::string(lname), std::string(descr),
314 | 					 std::string()),  val(b){}
315 |     virtual bool process(int &, const char **&){
316 |       val= !val;
317 |       return true;
318 |     }
319 |     virtual void write_value(std::ostream &out) const {
320 |       out << val;
321 |     }
322 | 
323 |     virtual void write_usage(std::ostream &out) const {
324 |       if (key != "") {
325 | 	out << '-' << key;
326 | 	out << "/--" << long_name;
327 |       }
328 |       out << "\t" << description;
329 |       out << " Value: ";
330 |       write_value(out);
331 |       out << std::endl;
332 |     }
333 |     virtual ~FlagTarget(){}
334 |   };
335 | 
336 |   class Argument_helper::DoubleTarget: public Argument_target{
337 |   public:
338 |     double &val;
339 |     DoubleTarget(const char *k, const char *lname,
340 | 		 const char *arg_descr, 
341 | 		 const char *descr, double &b): Argument_target(std::string(k), std::string(lname),
342 | 								    std::string(descr),
343 | 								    std::string(arg_descr)),  val(b){}
344 |     DoubleTarget(const char *arg_descr, 
345 | 		 const char *descr, double &b): Argument_target(std::string(descr),
346 | 								    std::string(arg_descr)),  val(b){}
347 |     virtual bool process(int &argc, const char **&argv){
348 |       if (argc==0){
349 | 	std::cerr << "Missing value for argument." << std::endl;
350 | 	return false;
351 |       }
352 |       if (sscanf(argv[0], "%le", &val) ==1){
353 | 	--argc;
354 | 	++argv;
355 | 	return true;
356 |       }  else {
357 | 	std::cerr << "Double not found at " << argv[0] << std::endl;
358 | 	return false;
359 |       }
360 |     }
361 |     virtual void write_value(std::ostream &out) const {
362 |       out << val;
363 |     }
364 |     virtual ~DoubleTarget(){}
365 |   };
366 | 
367 |   class Argument_helper::IntTarget: public Argument_target{
368 |   public:
369 |     int &val;
370 |     IntTarget(const char *arg_descr, 
371 | 	      const char *descr, int &b): Argument_target(std::string(descr), std::string(arg_descr)),
372 | 					      val(b){}
373 |     IntTarget(const char *k, const char *lname,
374 | 	      const char *arg_descr, 
375 | 	      const char *descr, int &b): Argument_target(std::string(k), std::string(lname),
376 | 							      std::string(descr),
377 | 							      std::string(arg_descr)), 
378 | 					      val(b){}
379 |     virtual bool process(int &argc, const char **&argv){
380 |       if (argc==0){
381 | 	std::cerr << "Missing value for argument." << std::endl;
382 | 	return false;
383 |       }
384 |       if (sscanf(argv[0], "%d", &val) ==1){
385 | 	--argc;
386 | 	++argv;
387 | 	return true;
388 |       }  else {
389 | 	std::cerr << "Integer not found at " << argv[0] << std::endl;
390 | 	return false;
391 |       }
392 |     }
393 |     virtual void write_value(std::ostream &out) const {
394 |       out << val;
395 |     }
396 |     virtual ~IntTarget(){}
397 |   };
398 | 
399 |   class Argument_helper::UIntTarget: public Argument_target{
400 |   public:
401 |     unsigned int &val;
402 |     UIntTarget(const char *arg_descr, 
403 | 	       const char *descr, unsigned int &b): Argument_target(std::string(descr), std::string(arg_descr)),
404 | 					       val(b){}
405 |     UIntTarget(const char *k, const char *lname,
406 | 	       const char *arg_descr, 
407 | 	       const char *descr, unsigned int &b): Argument_target(std::string(k), std::string(lname),
408 | 							       std::string(descr),
409 | 							       std::string(arg_descr)), 
410 | 					       val(b){}
411 |     virtual bool process(int &argc, const char **&argv){
412 |       if (argc==0){
413 | 	std::cerr << "Missing value for argument." << std::endl;
414 | 	return false;
415 |       }
416 |       if (sscanf(argv[0], "%ud", &val) ==1){
417 | 	--argc;
418 | 	++argv;
419 | 	return true;
420 |       } else {
421 | 	std::cerr << "Unsigned integer not found at " << argv[0] << std::endl;
422 | 	return false;
423 |       }
424 |     }
425 |     virtual void write_value(std::ostream &out) const {
426 |       out << val;
427 |     }
428 |     virtual ~UIntTarget(){}
429 |   };
430 |  
431 | 
432 |   class Argument_helper::CharTarget: public Argument_target{
433 |   public:
434 |     char &val;
435 |     CharTarget(const char *k, const char *lname,
436 | 	       const char *arg_descr, 
437 | 	       const char *descr, char &b): Argument_target(std::string(k), std::string(lname),
438 | 								std::string(descr),
439 | 								std::string(arg_descr)),  val(b){}
440 |     CharTarget(const char *arg_descr, 
441 | 	       const char *descr, char &b): Argument_target(std::string(descr),
442 | 								std::string(arg_descr)),  val(b){}
443 |     virtual bool process(int &argc, const char **&argv){
444 |       if (argc==0){
445 | 	std::cerr << "Missing value for argument." << std::endl;
446 | 	return false;
447 |       }
448 |       if (sscanf(argv[0], "%c", &val) ==1){
449 | 	--argc;
450 | 	++argv;
451 | 	return true;
452 |       }  else {
453 | 	std::cerr << "Character not found at " << argv[0] << std::endl;
454 | 	return false;
455 |       }
456 |     }
457 |     virtual void write_value(std::ostream &out) const {
458 |       out << val;
459 |     }
460 |     virtual ~CharTarget(){}
461 |   };
462 | 
463 | 
464 |   class Argument_helper::StringTarget: public Argument_target{
465 |   public:
466 |     std::string &val;
467 |     StringTarget(const char *arg_descr, 
468 | 		 const char *descr, std::string &b): Argument_target(std::string(descr),  std::string(arg_descr)),
469 | 							 val(b){}
470 | 
471 |     StringTarget(const char *k, const char *lname, const char *arg_descr,
472 | 		 const char *descr, std::string &b): Argument_target(std::string(k), std::string(lname),
473 | 		     std::string(descr), std::string(arg_descr)),
474 | 							 val(b){}
475 | 
476 |     virtual bool process(int &argc, const char **&argv){
477 |       if (argc==0){
478 | 	std::cerr << "Missing string argument." << std::endl;
479 | 	return false;
480 |       }
481 |       val= argv[0];
482 |       --argc;
483 |       ++argv;
484 |       return true;
485 |     }
486 |     virtual void write_value(std::ostream &out) const {
487 |       out << val;
488 |     }
489 |     virtual ~StringTarget(){}
490 |   };
491 | 
492 | 
493 |   class Argument_helper::StringVectorTarget: public Argument_target{
494 |   public:
495 |     std::vector<std::string> &val;
496 | 
497 |     StringVectorTarget(const char *k, const char *lname, const char *arg_descr,
498 | 		 const char *descr, std::vector<std::string> &b): Argument_target(std::string(k), std::string(lname),
499 | 		     std::string(descr), std::string(arg_descr)),
500 | 						     val(b){}
501 | 
502 |     virtual bool process(int &argc, const char **&argv){
503 |       while (argc >0 && argv[0][0] != '-'){
504 | 	val.push_back(argv[0]);
505 | 	--argc;
506 | 	++argv;
507 |       }
508 |       return true;
509 |     }
510 |     virtual void write_value(std::ostream &out) const {
511 |       for (unsigned int i=0; i< val.size(); ++i){
512 | 	out << val[i] << " ";
513 |       }
514 |     }
515 |     virtual ~StringVectorTarget(){}
516 |   };
517 | 
518 | 
519 |   //////////////////////////////////////////////// Argument_helper functions
520 | 
521 | 
522 |   Argument_helper::Argument_helper(){
523 |     author_="a programmer";
524 |     description_= "This program produces output.";
525 |     date_= "some day a long, long time ago.";
526 |     version_=-1;
527 |     extra_arguments_=NULL;
528 |     seen_end_named_=false;
529 |     new_flag("v", "verbose", "Whether to print extra information", verbose);
530 |     new_flag("V", "VERBOSE", "Whether to print lots of extra information", VERBOSE);
531 |   }
532 | 
533 | 
534 | 
535 |   void Argument_helper::set_string_vector(const char *arg_description, 
536 | 					  const char *description, 
537 | 					  std::vector<std::string> &dest){
538 |     assert(extra_arguments_==NULL);
539 |     extra_arguments_descr_= description;
540 |     extra_arguments_arg_descr_= arg_description;
541 |     extra_arguments_= &dest;
542 |   }
543 | 
544 |   void Argument_helper::set_author(const char *author){
545 |     author_=author;
546 |   }
547 | 
548 |   void Argument_helper::set_description(const char *descr){
549 |     description_= descr;
550 |   }
551 | 
552 |   void Argument_helper::set_name(const char *descr){
553 |     name_= descr;
554 |   }
555 | 
556 |   void Argument_helper::set_version(float v){
557 |     version_=v;
558 |   }
559 | 
560 |   void Argument_helper::set_version(const char *s){
561 |     version_=atof(s);
562 |   }
563 | 
564 |   void  Argument_helper::set_build_date(const char *date){
565 |     date_=date;
566 |   }
567 |   
568 |   void Argument_helper::new_argument_target(Argument_target *t) {
569 |     assert(t!= NULL);
570 |     if (t->key != ""){
571 |       if (short_names_.find(t->key) != short_names_.end()){
572 | 	std::cerr << "Two arguments are defined with the same string key, namely" << std::endl;
573 | 	short_names_[t->key]->write_usage(std::cerr);
574 | 	std::cerr << "\n and \n";
575 | 	t->write_usage(std::cerr);
576 | 	std::cerr << std::endl;
577 |       }
578 |       short_names_[t->key]= t;
579 |     } 
580 |     if (!t->long_name.empty()){
581 |       if (long_names_.find(t->long_name) != long_names_.end()){
582 | 	std::cerr << "Two arguments are defined with the same long key, namely" << std::endl;
583 | 	long_names_[t->long_name]->write_usage(std::cerr);
584 | 	std::cerr << "\n and \n";
585 | 	t->write_usage(std::cerr);
586 | 	std::cerr << std::endl;
587 |       }
588 |       long_names_[t->long_name]= t;
589 |     }
590 |     all_arguments_.push_back(t);
591 |   }
592 |   
593 |   void Argument_helper::new_flag(const char *key, const char *long_name, const char *description,bool &dest){
594 |     Argument_target *t= new FlagTarget(key, long_name, description, dest);
595 |     new_argument_target(t);
596 |   };
597 | 
598 | 
599 | 
600 |   void Argument_helper::new_string(const char *arg_description, const char *description,
601 | 				   std::string &dest){
602 |     Argument_target *t= new StringTarget(arg_description, description, dest);
603 |     unnamed_arguments_.push_back(t);
604 |     all_arguments_.push_back(t);
605 |   };
606 |   void Argument_helper::new_optional_string(const char *arg_description, const char *description,
607 | 					    std::string &dest){
608 |     Argument_target *t= new StringTarget(arg_description, description, dest);
609 |     optional_unnamed_arguments_.push_back(t);
610 |   };
611 |   void Argument_helper::new_named_string(const char *key, const char *long_name,
612 | 					 const char *arg_description, const char *description,
613 | 					 std::string &dest){
614 |     Argument_target *t= new StringTarget(key, long_name, arg_description, description, dest);
615 |     new_argument_target(t);
616 |   };
617 | 
618 | 
619 |   void Argument_helper::new_named_string_vector(const char *key, const char *long_name,
620 | 					 const char *arg_description, const char *description,
621 | 					 std::vector<std::string> &dest){
622 |     Argument_target *t= new StringVectorTarget(key, long_name, arg_description, description, dest);
623 |     new_argument_target(t);
624 |   };
625 | 
626 | 
627 | 
628 |   void Argument_helper::new_int(const char *arg_description, const char *description,
629 | 				   int &dest){
630 |     Argument_target *t= new IntTarget(arg_description, description, dest);
631 |     unnamed_arguments_.push_back(t);
632 |     all_arguments_.push_back(t);
633 |   };
634 |   void Argument_helper::new_optional_int(const char *arg_description, const char *description,
635 | 					    int &dest){
636 |     Argument_target *t= new IntTarget(arg_description, description, dest);
637 |     optional_unnamed_arguments_.push_back(t);
638 |   };
639 |   void Argument_helper::new_named_int(const char *key, const char *long_name,
640 | 					 const char *arg_description, const char *description,
641 | 					 int &dest){
642 |     Argument_target *t= new IntTarget(key, long_name, arg_description, description, dest);
643 |     new_argument_target(t);
644 |   };
645 | 
646 |   void Argument_helper::new_unsigned_int(const char *arg_description, const char *description,
647 | 					unsigned int &dest){
648 |     Argument_target *t= new UIntTarget(arg_description, description, dest);
649 |     unnamed_arguments_.push_back(t);
650 |     all_arguments_.push_back(t);
651 |   };
652 |   void Argument_helper::new_optional_unsigned_int(const char *arg_description, const char *description,
653 | 					    unsigned int &dest){
654 |     Argument_target *t= new UIntTarget(arg_description, description, dest);
655 |     optional_unnamed_arguments_.push_back(t);
656 |   };
657 |   void Argument_helper::new_named_unsigned_int(const char *key, const char *long_name,
658 | 					       const char *arg_description, const char *description,
659 | 					       unsigned int &dest){
660 |     Argument_target *t= new UIntTarget(key, long_name, arg_description, description, dest);
661 |     new_argument_target(t);
662 |   };
663 | 
664 | 
665 |   void Argument_helper::new_double(const char *arg_description, const char *description,
666 | 				   double &dest){
667 |     Argument_target *t= new DoubleTarget(arg_description, description, dest);
668 |     unnamed_arguments_.push_back(t);
669 |     all_arguments_.push_back(t);
670 |   };
671 |   void Argument_helper::new_optional_double(const char *arg_description, const char *description,
672 | 					    double &dest){
673 |     Argument_target *t= new DoubleTarget(arg_description, description, dest);
674 |     optional_unnamed_arguments_.push_back(t);
675 |   };
676 |   void Argument_helper::new_named_double(const char *key, const char *long_name,
677 | 					 const char *arg_description, const char *description,
678 | 					 double &dest){
679 |     Argument_target *t= new DoubleTarget(key, long_name, arg_description, description, dest);
680 |     new_argument_target(t);
681 |   };
682 | 
683 |   void Argument_helper::new_char(const char *arg_description, const char *description,
684 | 				 char &dest){
685 |     Argument_target *t= new CharTarget(arg_description, description, dest);
686 |     unnamed_arguments_.push_back(t);
687 |     all_arguments_.push_back(t);
688 |   };
689 |   void Argument_helper::new_optional_char(const char *arg_description, const char *description,
690 | 					    char &dest){
691 |     Argument_target *t= new CharTarget(arg_description, description, dest);
692 |     optional_unnamed_arguments_.push_back(t);
693 |   };
694 |   void Argument_helper::new_named_char(const char *key, const char *long_name,
695 | 					 const char *arg_description, const char *description,
696 | 					 char &dest){
697 |     Argument_target *t= new CharTarget(key, long_name, arg_description, description, dest);
698 |     new_argument_target(t);
699 |   };
700 | 
701 | 
702 | 
703 |   void Argument_helper::write_usage(std::ostream &out) const {
704 |     out << name_ << " version " << version_ << ", by " << author_ << std::endl;
705 |     out << description_ << std::endl;
706 |     out << "Compiled on " << date_ << std::endl << std::endl;
707 |     out << "Usage: " << name_  << " ";
708 |     for (UVect::const_iterator it= unnamed_arguments_.begin(); it != unnamed_arguments_.end(); ++it){
709 |       (*it)->write_name(out);
710 |       out << " ";
711 |     }
712 |     for (UVect::const_iterator it= optional_unnamed_arguments_.begin(); 
713 | 	 it != optional_unnamed_arguments_.end(); ++it){
714 |       out << "[";
715 |       (*it)->write_name(out);
716 |       out << "] ";
717 |     }
718 |     if (extra_arguments_ != NULL) {
719 |       out << "[" << extra_arguments_arg_descr_ << "]";
720 |     }    
721 | 
722 |     out << std::endl << std::endl;
723 |     out << "All arguments:\n";
724 |     for (UVect::const_iterator it= unnamed_arguments_.begin(); it != unnamed_arguments_.end(); ++it){
725 |       (*it)->write_usage(out);
726 |     }
727 |     for (UVect::const_iterator it= optional_unnamed_arguments_.begin(); 
728 | 	 it != optional_unnamed_arguments_.end(); ++it){
729 |       (*it)->write_usage(out);
730 |     }
731 | 
732 |    if (!extra_arguments_arg_descr_.empty()) {
733 |      out << extra_arguments_arg_descr_ << ": " << extra_arguments_descr_ << std::endl;
734 |    }
735 |     for (SMap::const_iterator it= short_names_.begin(); it != short_names_.end(); ++it){
736 |       (it->second)->write_usage(out);
737 |     }
738 |   }
739 | 
740 | 
741 | 
742 |   void Argument_helper::write_values(std::ostream &out) const {
743 |     for (UVect::const_iterator it= unnamed_arguments_.begin(); it != unnamed_arguments_.end(); ++it){
744 |       out << (*it)->description;
745 |       out << ": ";
746 |       (*it)->write_value(out);
747 |       out << std::endl;
748 |     }
749 |     for (UVect::const_iterator it= optional_unnamed_arguments_.begin(); 
750 | 	 it != optional_unnamed_arguments_.end(); ++it){
751 |       out << (*it)->description;
752 |       out << ": ";
753 |       (*it)->write_value(out);
754 |       out << std::endl;
755 |     }
756 |     if (extra_arguments_!=NULL){
757 |       for (std::vector<std::string>::const_iterator it= extra_arguments_->begin(); 
758 | 	   it != extra_arguments_->end(); ++it){
759 | 	out << *it << " ";
760 |       }
761 |     }
762 | 
763 |     for (SMap::const_iterator it= short_names_.begin(); it != short_names_.end(); ++it){
764 |       out << it->second->description;
765 |       out << ": ";
766 |       it->second->write_value(out);
767 |       out << std::endl;
768 |     }
769 |   }
770 | 
771 |   Argument_helper::~Argument_helper(){
772 |     for (std::vector<Argument_target*>::iterator it= all_arguments_.begin();
773 | 	 it != all_arguments_.end(); ++it){
774 |       delete *it;
775 |     }
776 |   }
777 | 
778 | 
779 |   void Argument_helper::process(int argc,  const char **argv){
780 |     name_= argv[0];
781 |     ++argv;
782 |     --argc;
783 | 
784 |     current_unnamed_= unnamed_arguments_.begin();
785 |     current_optional_unnamed_= optional_unnamed_arguments_.begin();
786 |     
787 |     for ( int i=0; i< argc; ++i){
788 |       if (strcmp(argv[i], "--help") == 0){
789 | 	write_usage(std::cout);
790 | 	exit(0);
791 |       }
792 |     }
793 | 
794 |     while (argc != 0){
795 | 
796 |       const char* cur_arg= argv[0];
797 |       if (cur_arg[0]=='-' && !seen_end_named_){
798 | 	--argc; ++argv;
799 | 	if (cur_arg[1]=='-'){
800 | 	  if (cur_arg[2] == '\0') {
801 | 	    //std::cout << "Ending flags " << std::endl;
802 | 	    seen_end_named_=true;
803 | 	  } else {
804 | 	    // long argument
805 | 	    LMap::iterator f= long_names_.find(cur_arg+2);
806 | 	    if ( f != long_names_.end()){
807 | 	      if (!f->second->process(argc, argv)) {
808 | 		handle_error();
809 | 	      }
810 | 	    } else {
811 | 	      std::cerr<< "Invalid long argument "<< cur_arg << ".\n";
812 | 	      handle_error();
813 | 	    }
814 | 	  }
815 | 	} else {
816 | 	  if (cur_arg[1]=='\0') {
817 | 	    std::cerr << "Invalid argument " << cur_arg << ".\n";
818 | 	    handle_error();
819 | 	  }
820 | 	  SMap::iterator f= short_names_.find(cur_arg+1);
821 | 	  if ( f != short_names_.end()){
822 | 	    if (!f->second->process(argc, argv)) {
823 | 	      handle_error();
824 | 	    }
825 | 	  } else {
826 | 	    std::cerr<< "Invalid short argument "<< cur_arg << ".\n";
827 | 	    handle_error();
828 | 	  }
829 |  	}
830 |       } else {
831 | 	if (current_unnamed_ != unnamed_arguments_.end()){
832 | 	  Argument_target *t= *current_unnamed_;
833 | 	  t->process(argc, argv);
834 | 	  ++current_unnamed_;
835 | 	} else if (current_optional_unnamed_ != optional_unnamed_arguments_.end()){
836 | 	  Argument_target *t= *current_optional_unnamed_;
837 | 	  t->process(argc, argv);
838 | 	  ++current_optional_unnamed_;
839 | 	} else if (extra_arguments_!= NULL){
840 | 	  extra_arguments_->push_back(cur_arg);
841 | 	  --argc;
842 | 	  ++argv;
843 | 	} else {
844 | 	  std::cerr << "Invalid extra argument " << argv[0] << std::endl;
845 | 	  handle_error();
846 | 	}
847 |       }
848 |     }
849 | 
850 |     if (current_unnamed_ != unnamed_arguments_.end()){
851 |       std::cerr << "Missing required arguments:" << std::endl;
852 |       for (; current_unnamed_ != unnamed_arguments_.end(); ++current_unnamed_){
853 | 	(*current_unnamed_)->write_name(std::cerr);
854 | 	std::cerr << std::endl;
855 |       }
856 |       std::cerr << std::endl;
857 |       handle_error();
858 |     }
859 | 
860 |     if (VERBOSE) verbose=true;
861 |   }
862 | 
863 |   void Argument_helper::handle_error() const {
864 |     write_usage(std::cerr);
865 |     exit(1);
866 |   }
867 |   
868 | }
869 | 
870 | 
871 | 
872 | 
873 | 
874 | #endif
875 | 


--------------------------------------------------------------------------------
/ade/NNade3.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef NNADE3_H_
  3 | #define NNADE3_H_
  4 | 
  5 | #include <iosfwd>
  6 | #include "Options.h"
  7 | #include "Tool.h"
  8 | #include "FoxUtil.h"
  9 | #include "N3Lhelper.h"
 10 | #include "Utf.h"
 11 | #include "Token.h"
 12 | #include "Sent.h"
 13 | #include <sstream>
 14 | #include "Dependency.h"
 15 | #include "N3L.h"
 16 | #include "EnglishPos.h"
 17 | #include "Punctuation.h"
 18 | #include "Word2Vec.h"
 19 | #include "utils.h"
 20 | #include "Example.h"
 21 | #include "BestPerformance.h"
 22 | 
 23 | #include "Classifier3.h"
 24 | 
 25 | using namespace nr;
 26 | using namespace std;
 27 | 
 28 | // a implement of ACL 2016 end-to-end relation extraction
 29 | // use relation f1 on the development set
 30 | 
 31 | class NNade3 {
 32 | public:
 33 | 	Options m_options;
 34 | 
 35 | 	Alphabet m_wordAlphabet;
 36 | 	Alphabet m_posAlphabet;
 37 | 	Alphabet m_nerAlphabet;
 38 | 	Alphabet m_depAlphabet;
 39 | 	Alphabet m_charAlphabet;
 40 | 
 41 | 	string unknownkey;
 42 | 	string nullkey;
 43 | 
 44 | #if USE_CUDA==1
 45 |   Classifier<gpu> m_classifier;
 46 | #else
 47 |   //Classifier3_base<cpu> m_classifier;
 48 |   //Classifier3_char<cpu> m_classifier;
 49 |   //Classifier3_pos<cpu> m_classifier;
 50 |   //Classifier3_ner<cpu> m_classifier;
 51 |   //Classifier3_label<cpu> m_classifier;
 52 |   //Classifier3_dep<cpu> m_classifier;
 53 |   //Classifier3_entity<cpu> m_classifier;
 54 |   //Classifier3_nosdp<cpu> m_classifier;
 55 |   //Classifier3_nojoint<cpu> m_classifier;
 56 |   Classifier3<cpu> m_classifier;
 57 | #endif
 58 | 
 59 | 
 60 |   NNade3(const Options &options):m_options(options) {
 61 | 		unknownkey = "-#unknown#-";
 62 | 		nullkey = "-#null#-";
 63 | 	}
 64 | 
 65 | 
 66 |   BestPerformance trainAndTest(vector<fox::Sent> & processedTest, vector<ADEsentence> & annotatedTest,
 67 | 			vector<fox::Sent> & processedDev, vector<ADEsentence> & annotatedDev,
 68 | 			vector<fox::Sent> & processedTrain, vector<ADEsentence> & annotatedTrain, Tool & tool) {
 69 | 
 70 | 	  	BestPerformance ret;
 71 | 
 72 | 		m_wordAlphabet.clear();
 73 | 		m_wordAlphabet.from_string(unknownkey);
 74 | 		m_wordAlphabet.from_string(nullkey);
 75 | 
 76 | 		m_posAlphabet.clear();
 77 | 		m_posAlphabet.from_string(unknownkey);
 78 | 		m_posAlphabet.from_string(nullkey);
 79 | 
 80 | 		m_depAlphabet.clear();
 81 | 		m_depAlphabet.from_string(unknownkey);
 82 | 		m_depAlphabet.from_string(nullkey);
 83 | 
 84 | 		m_charAlphabet.clear();
 85 | 		m_charAlphabet.from_string(unknownkey);
 86 | 		m_charAlphabet.from_string(nullkey);
 87 | 
 88 | 		// ner alphabet should be initialized directly, not from the dataset
 89 | 		m_nerAlphabet.clear();
 90 | 		m_nerAlphabet.from_string(unknownkey);
 91 | 		m_nerAlphabet.from_string(nullkey);
 92 | 		hash_map<string, int> ner_stat;
 93 | 		ner_stat[B_Disease]++;
 94 | 		ner_stat[I_Disease]++;
 95 | 		ner_stat[L_Disease]++;
 96 | 		ner_stat[U_Disease]++;
 97 | 		ner_stat[B_Chemical]++;
 98 | 		ner_stat[I_Chemical]++;
 99 | 		ner_stat[L_Chemical]++;
100 | 		ner_stat[U_Chemical]++;
101 | 		ner_stat[OTHER]++;
102 | 		stat2Alphabet(ner_stat, m_nerAlphabet, "ner");
103 | 
104 | 		createAlphabet(processedTrain, tool);
105 | 
106 | 		if (!m_options.wordEmbFineTune) {
107 | 			createAlphabet(processedDev, tool);
108 | 			createAlphabet(processedTest, tool);
109 | 		}
110 | 
111 | 
112 | 		NRMat<dtype> wordEmb;
113 | 		if(m_options.wordEmbFineTune) {
114 | 			if(m_options.embFile.empty()) {
115 | 				cout<<"random emb"<<endl;
116 | 
117 | 				randomInitNrmat(wordEmb, m_wordAlphabet, m_options.wordEmbSize, 1000);
118 | 			} else {
119 | 
120 | 				double* emb = new double[m_wordAlphabet.size()*m_options.wordEmbSize];
121 | 				fox::initArray2((double *)emb, (int)m_wordAlphabet.size(), m_options.wordEmbSize, 0.0);
122 | 				vector<string> known;
123 | 				map<string, int> IDs;
124 | 				alphabet2vectormap(m_wordAlphabet, known, IDs);
125 | 
126 | 				tool.w2v->getEmbedding((double*)emb, m_options.wordEmbSize, known, unknownkey, IDs);
127 | 
128 | 				wordEmb.resize(m_wordAlphabet.size(), m_options.wordEmbSize);
129 | 				array2NRMat((double*) emb, m_wordAlphabet.size(), m_options.wordEmbSize, wordEmb);
130 | 
131 | 				delete[] emb;
132 | 			}
133 | 		} else {
134 | 			if(m_options.embFile.empty()) {
135 | 				assert(0);
136 | 			} else {
137 | 
138 | 				double* emb = new double[m_wordAlphabet.size()*m_options.wordEmbSize];
139 | 				fox::initArray2((double *)emb, (int)m_wordAlphabet.size(), m_options.wordEmbSize, 0.0);
140 | 				vector<string> known;
141 | 				map<string, int> IDs;
142 | 				alphabet2vectormap(m_wordAlphabet, known, IDs);
143 | 
144 | 				tool.w2v->getEmbedding((double*)emb, m_options.wordEmbSize, known, unknownkey, IDs);
145 | 
146 | 				wordEmb.resize(m_wordAlphabet.size(), m_options.wordEmbSize);
147 | 				array2NRMat((double*) emb, m_wordAlphabet.size(), m_options.wordEmbSize, wordEmb);
148 | 
149 | 				delete[] emb;
150 | 			}
151 | 		}
152 | 
153 | 		NRMat<dtype> posEmb;
154 | 		randomInitNrmat(posEmb, m_posAlphabet, m_options.otherEmbSize, 1010);
155 | 		NRMat<dtype> nerEmb;
156 | 		randomInitNrmat(nerEmb, m_nerAlphabet, m_options.otherEmbSize, 1020);
157 | 		NRMat<dtype> depEmb;
158 | 		randomInitNrmat(depEmb, m_depAlphabet, m_options.otherEmbSize, 1030);
159 | 		NRMat<dtype> charEmb;
160 | 		randomInitNrmat(charEmb, m_charAlphabet, m_options.otherEmbSize, 1040);
161 | 
162 | 		vector<Example> trainExamples;
163 | 		initialTrainingExamples(tool, annotatedTrain, processedTrain, trainExamples);
164 | 		cout<<"Total train example number: "<<trainExamples.size()<<endl;
165 | 
166 | 		  m_classifier.init(m_options);
167 | 
168 | 		  m_classifier._words.initial(wordEmb);
169 | 		  m_classifier._words.setEmbFineTune(m_options.wordEmbFineTune);
170 | 
171 | 		m_classifier._pos.initial(posEmb);
172 | 		m_classifier._pos.setEmbFineTune(true);
173 | 
174 | 		m_classifier._dep.initial(depEmb);
175 | 		m_classifier._dep.setEmbFineTune(true);
176 | 
177 | 		m_classifier._ner.initial(nerEmb);
178 | 		m_classifier._ner.setEmbFineTune(true);
179 | 
180 | 		m_classifier._char.initial(charEmb);
181 | 		m_classifier._char.setEmbFineTune(true);
182 | 
183 | 
184 | 		static vector<Example> subExamples;
185 | 
186 | 		dtype best = 0;
187 | 
188 | 		// begin to train
189 | 		for (int iter = 0; iter < m_options.maxIter; ++iter) {
190 | 
191 | 			cout << "##### Iteration " << iter << std::endl;
192 | 
193 | 		    // this coding block should be identical to initialTrainingExamples
194 | 		    // we don't regenerate training examples, instead fetch them directly
195 | 		    int exampleIdx = 0;
196 | 
197 | 			for(int sentIdx=0;sentIdx<processedTrain.size();sentIdx++) {
198 | 				const fox::Sent & sent = processedTrain[sentIdx];
199 | 				const ADEsentence & annotatedSent = annotatedTrain[sentIdx];
200 | 
201 | 				for(int tokenIdx=0;tokenIdx<sent.tokens.size();tokenIdx++) {
202 | 					const fox::Token& token = sent.tokens[tokenIdx];
203 | 
204 | 					subExamples.clear();
205 | 					subExamples.push_back(trainExamples[exampleIdx]);
206 | 					int curUpdateIter = iter * trainExamples.size() + exampleIdx;
207 | 
208 | 					dtype cost = m_classifier.processNer(subExamples, curUpdateIter);
209 | 
210 | 					//m_classifier.checkgradsNer(subExamples, curUpdateIter);
211 | 					m_classifier.updateParams(m_options.regParameter, m_options.adaAlpha, m_options.adaEps);
212 | 
213 | 
214 | 					exampleIdx++;
215 | 				} // token
216 | 
217 | 				for(int bIdx=0;bIdx<annotatedSent.entities.size();bIdx++) {
218 | 					const Entity& bEntity = annotatedSent.entities[bIdx];
219 | 
220 | 					// a is before b
221 | 					for(int aIdx=0;aIdx<bIdx;aIdx++) {
222 | 						const Entity& aEntity = annotatedSent.entities[aIdx];
223 | 
224 | 						// type constraint
225 | 						if(aEntity.type==bEntity.type)	{
226 | 							continue;
227 | 						}
228 | 
229 | 						subExamples.clear();
230 | 						subExamples.push_back(trainExamples[exampleIdx]);
231 | 						int curUpdateIter = iter * trainExamples.size() + exampleIdx;
232 | 
233 | 						dtype cost = m_classifier.processRel(subExamples, curUpdateIter);
234 | 						//m_classifier.checkgradsRel(subExamples, curUpdateIter);
235 | 						m_classifier.updateParams(m_options.regParameter, m_options.adaAlpha, m_options.adaEps);
236 | 
237 | 
238 | 						exampleIdx++;
239 | 
240 | 					} // aIdx
241 | 
242 | 				} // bIdx
243 | 
244 | 
245 | 			} // sent
246 | 
247 | 
248 | 
249 | 		    // an iteration end, begin to evaluate
250 | 		    if((iter+1)% m_options.evalPerIter ==0) {
251 | 
252 | 		    	if(m_options.wordEmbFineTune && m_options.wordCutOff == 0) {
253 | 
254 | 		    		averageUnkownEmb(m_wordAlphabet, m_classifier._words, m_options.wordEmbSize);
255 | 
256 | 		    		averageUnkownEmb(m_posAlphabet, m_classifier._pos, m_options.otherEmbSize);
257 | 
258 | 		    		averageUnkownEmb(m_depAlphabet, m_classifier._dep, m_options.otherEmbSize);
259 | 
260 | 		    		averageUnkownEmb(m_nerAlphabet, m_classifier._ner, m_options.otherEmbSize);
261 | 
262 | 
263 | 		    		averageUnkownEmb(m_charAlphabet, m_classifier._char, m_options.otherEmbSize);
264 | 		    	}
265 | 
266 | 		    	BestPerformance currentDev = evaluateOnDev(tool, annotatedDev, processedDev, iter);
267 | 
268 | /*				if (currentDev.dev_f1Relation > best) {
269 | 					cout << "Exceeds best performance of " << best << endl;
270 | 					best = currentDev.dev_f1Relation;
271 | 
272 | 					BestPerformance currentTest = test(tool, annotatedTest, processedTest);
273 | 
274 | 
275 | 					ret.dev_pEntity = currentDev.dev_pEntity;
276 | 					ret.dev_rEntity = currentDev.dev_rEntity;
277 | 					ret.dev_f1Entity = currentDev.dev_f1Entity;
278 | 					ret.dev_pRelation = currentDev.dev_pRelation;
279 | 					ret.dev_rRelation = currentDev.dev_rRelation;
280 | 					ret.dev_f1Relation = currentDev.dev_f1Relation;
281 | 					ret.test_pEntity = currentTest.test_pEntity;
282 | 					ret.test_rEntity = currentTest.test_rEntity;
283 | 					ret.test_f1Entity = currentTest.test_f1Entity;
284 | 					ret.test_pRelation = currentTest.test_pRelation;
285 | 					ret.test_rRelation = currentTest.test_rRelation;
286 | 					ret.test_f1Relation = currentTest.test_f1Relation;
287 | 
288 | 				}*/
289 | 
290 | 		    }
291 | 
292 | 		} // for iter
293 | 
294 | 		m_classifier.release();
295 | 
296 | 		return ret;
297 | 	}
298 | 
299 | 
300 | 	void initialTrainingExamples(Tool& tool, vector<ADEsentence> & annotated, vector<fox::Sent> & processed,
301 | 			vector<Example> & examples) {
302 | 
303 | 
304 | 		for(int sentIdx=0;sentIdx<processed.size();sentIdx++) {
305 | 			const fox::Sent & sent = processed[sentIdx];
306 | 			const ADEsentence & annotatedSent =annotated[sentIdx];
307 | 			string lastNerLabel = nullkey;
308 | 			vector<string> labelSequence;
309 | 
310 | 			for(int tokenIdx=0;tokenIdx<sent.tokens.size();tokenIdx++) {
311 | 				const fox::Token& token = sent.tokens[tokenIdx];
312 | 				int entityIdx = -1;
313 | 				string schemaLabel = OTHER;
314 | 
315 | 				for(int i=0;i<annotatedSent.entities.size();i++) {
316 | 					const Entity& entity = annotatedSent.entities[i];
317 | 
318 | 					string temp = isTokenInEntity(token, entity);
319 | 					if(temp != OTHER) {
320 | 						entityIdx = i;
321 | 						schemaLabel = temp;
322 | 						break;
323 | 					}
324 | 				}
325 | 
326 | 				Example eg(false);
327 | 				string labelName = entityIdx!=-1 ? schemaLabel+"_"+annotatedSent.entities[entityIdx].type : OTHER;
328 | 				generateOneNerExample(eg, labelName, sent, lastNerLabel, tokenIdx);
329 | 				labelSequence.push_back(labelName);
330 | 
331 | 				examples.push_back(eg);
332 | 
333 | 				lastNerLabel = labelName;
334 | 			} // token
335 | 
336 | 			for(int bIdx=0;bIdx<annotatedSent.entities.size();bIdx++) {
337 | 				const Entity& bEntity = annotatedSent.entities[bIdx];
338 | 
339 | 				// a is before b
340 | 				for(int aIdx=0;aIdx<bIdx;aIdx++) {
341 | 					const Entity& aEntity = annotatedSent.entities[aIdx];
342 | 
343 | 					// type constraint
344 | 					if((aEntity.type==bEntity.type))	{
345 | 						continue;
346 | 					}
347 | 
348 | 					const Entity& Disease = aEntity.type==TYPE_Disease? aEntity:bEntity;
349 | 					const Entity& Chemical = aEntity.type==TYPE_Disease? bEntity:aEntity;
350 | 
351 | 					Example eg(true);
352 | 					string labelName = Not_ADE;
353 | 					if(isADE(Disease, Chemical, annotatedSent)) {
354 | 						labelName = ADE;
355 | 					}
356 | 
357 | 					generateOneRelExample(eg, labelName, sent, Disease, Chemical, labelSequence);
358 | 
359 | 					examples.push_back(eg);
360 | 
361 | 				} // aIdx
362 | 
363 | 			} // bIdx
364 | 
365 | 
366 | 		} // sent
367 | 
368 | 
369 | 
370 | 	}
371 | 
372 | 	BestPerformance evaluateOnDev(Tool& tool, vector<ADEsentence> & annotated,
373 | 			vector<fox::Sent> & processed, int iter) {
374 | 
375 | 		BestPerformance ret;
376 | 
377 |     	int ctGoldEntity = 0;
378 |     	int ctPredictEntity = 0;
379 |     	int ctCorrectEntity = 0;
380 |     	int ctGoldRelation = 0, ctPredictRelation = 0, ctCorrectRelation = 0;
381 | 
382 | 		for(int sentIdx=0;sentIdx<processed.size();sentIdx++) {
383 | 			const fox::Sent & sent = processed[sentIdx];
384 | 			const ADEsentence & annotatedSent =annotated[sentIdx];
385 | 			string lastNerLabel = nullkey;
386 | 			vector<string> labelSequence;
387 | 
388 | 			vector<Entity> anwserEntities;
389 | 			vector<Relation> anwserRelations;
390 | 
391 | 	    	vector<Relation> fnRelations;
392 | 
393 | 			for(int tokenIdx=0;tokenIdx<sent.tokens.size();tokenIdx++) {
394 | 				const fox::Token& token = sent.tokens[tokenIdx];
395 | 
396 | 				Example eg(false);
397 | 				string fakeLabelName = "";
398 | 				generateOneNerExample(eg, fakeLabelName, sent, lastNerLabel, tokenIdx);
399 | 
400 | 				vector<dtype> probs;
401 | 				int predicted = m_classifier.predictNer(eg, probs);
402 | 
403 | 				string labelName = NERlabelID2labelName(predicted);
404 | 				labelSequence.push_back(labelName);
405 | 
406 | 				// decode entity label
407 | 				if(labelName == B_Disease || labelName == U_Disease ||
408 | 						labelName == B_Chemical || labelName == U_Chemical) {
409 | 					Entity entity;
410 | 					newEntity(token, labelName, entity);
411 | 					anwserEntities.push_back(entity);
412 | 				} else if(labelName == I_Disease || labelName == L_Disease ||
413 | 						labelName == I_Chemical || labelName == L_Chemical) {
414 | 					if(checkWrongState(labelSequence)) {
415 | 						Entity& entity = anwserEntities[anwserEntities.size()-1];
416 | 						appendEntity(token, entity);
417 | 					}
418 | 				}
419 | 
420 | 				lastNerLabel = labelName;
421 | 			} // token
422 | 
423 | 			for(int bIdx=0;bIdx<anwserEntities.size();bIdx++) {
424 | 				const Entity& bEntity = anwserEntities[bIdx];
425 | 
426 | 				// a is before b
427 | 				for(int aIdx=0;aIdx<bIdx;aIdx++) {
428 | 					const Entity& aEntity = anwserEntities[aIdx];
429 | 
430 | 					// type constraint
431 | 					if(aEntity.type==bEntity.type)	{
432 | 						continue;
433 | 					}
434 | 
435 | 					const Entity& Disease = aEntity.type==TYPE_Disease? aEntity:bEntity;
436 | 					const Entity& Chemical = aEntity.type==TYPE_Disease? bEntity:aEntity;
437 | 
438 | 					Example eg(true);
439 | 					string fakeLabelName = "";
440 | 					generateOneRelExample(eg, fakeLabelName, sent, Disease, Chemical, labelSequence);
441 | 
442 | 					vector<dtype> probs;
443 | 					int predicted = m_classifier.predictRel(eg, probs);
444 | 
445 | 					string labelName = RellabelID2labelName(predicted);
446 | 
447 | 					// decode relation label
448 | 					if(labelName == ADE) {
449 | 						Relation relation;
450 | 						newRelation(relation, Disease, Chemical);
451 | 						anwserRelations.push_back(relation);
452 | 					}
453 | 
454 | 				} // aIdx
455 | 
456 | 			} // bIdx
457 | 
458 | 			// evaluate by ourselves
459 | 			ctGoldEntity += annotatedSent.entities.size();
460 | 			ctPredictEntity += anwserEntities.size();
461 | 			for(int i=0;i<anwserEntities.size();i++) {
462 | 				int k=-1;
463 | 				int j=0;
464 | 				for(;j<annotatedSent.entities.size();j++) {
465 | 					if(anwserEntities[i].equalsBoundary(annotatedSent.entities[j])) {
466 | 						if(anwserEntities[i].equalsType(annotatedSent.entities[j])) {
467 | 							ctCorrectEntity ++;
468 | 							break;
469 | 						} else {
470 | 							k = j;
471 | 							break;
472 | 						}
473 | 					}
474 | 				}
475 | 
476 | 
477 | 			}
478 | 
479 | 			for(int i=0;i<annotatedSent.entities.size();i++) {
480 | 				int k=-1;
481 | 				int j=0;
482 | 				for(;j<anwserEntities.size();j++) {
483 | 					if(annotatedSent.entities[i].equalsBoundary(anwserEntities[j])) {
484 | 						if(annotatedSent.entities[i].equalsType(anwserEntities[j])) {
485 | 							break;
486 | 						} else {
487 | 							k = j;
488 | 							break;
489 | 						}
490 | 					}
491 | 
492 | 				}
493 | 
494 | 
495 | 			}
496 | 
497 | 			ctGoldRelation += annotatedSent.relations.size();
498 | 			ctPredictRelation += anwserRelations.size();
499 | 			for(int i=0;i<anwserRelations.size();i++) {
500 | 				int j=0;
501 | 				for(;j<annotatedSent.relations.size();j++) {
502 | 					if(anwserRelations[i].equals(annotatedSent.relations[j])) {
503 | 						ctCorrectRelation ++;
504 | 						break;
505 | 					}
506 | 				}
507 | 
508 | 			}
509 | 
510 | 			for(int i=0;i<annotatedSent.relations.size();i++) {
511 | 				int j=0;
512 | 				for(;j<anwserRelations.size();j++) {
513 | 					if(annotatedSent.relations[i].equals(anwserRelations[j])) {
514 | 						break;
515 | 					}
516 | 				}
517 | 
518 | 				if(j>=anwserRelations.size()) {
519 | 					fnRelations.push_back(annotatedSent.relations[i]);
520 | 				}
521 | 			}
522 | 
523 | 			for(int i=0;i<fnRelations.size();i++) {
524 | 				bool entity1Matched = false;
525 | 				bool entity2Matched = false;
526 | 				for(int j=0;j<anwserEntities.size();j++) {
527 | 					if(entity1Matched==false && fnRelations[i].entity1.equals(anwserEntities[j])) {
528 | 						entity1Matched = true;
529 | 					} else if(entity2Matched==false && fnRelations[i].entity2.equals(anwserEntities[j])) {
530 | 						entity2Matched = true;
531 | 					}
532 | 				}
533 | 
534 | 			}
535 | 
536 | 
537 | 		} // sent
538 | 
539 | 		ret.dev_pEntity = precision(ctCorrectEntity, ctPredictEntity);
540 | 		ret.dev_rEntity = recall(ctCorrectEntity, ctGoldEntity);
541 | 		ret.dev_f1Entity = f1(ctCorrectEntity, ctGoldEntity, ctPredictEntity);
542 | 		ret.dev_pRelation = precision(ctCorrectRelation, ctPredictRelation);
543 | 		ret.dev_rRelation = recall(ctCorrectRelation, ctGoldRelation);
544 | 		ret.dev_f1Relation = f1(ctCorrectRelation, ctGoldRelation, ctPredictRelation);
545 | 
546 | 		cout<<"dev entity p: "<<ret.dev_pEntity<<", r:"<<ret.dev_rEntity<<", f1:"<<ret.dev_f1Entity<<endl;
547 | 		cout<<"dev relation p: "<<ret.dev_pRelation<<", r:"<<ret.dev_rRelation<<", f1:"<<ret.dev_f1Relation<<endl;
548 | 
549 | 
550 | 		return ret;
551 | 	}
552 | 
553 | 	BestPerformance test(Tool& tool, vector<ADEsentence> & annotated, vector<fox::Sent> & processed) {
554 | 
555 | 		BestPerformance ret;
556 | 
557 |     	int ctGoldEntity = 0;
558 |     	int ctPredictEntity = 0;
559 |     	int ctCorrectEntity = 0;
560 |     	int ctGoldRelation = 0, ctPredictRelation = 0, ctCorrectRelation = 0;
561 | 
562 | 		for(int sentIdx=0;sentIdx<processed.size();sentIdx++) {
563 | 			const fox::Sent & sent = processed[sentIdx];
564 | 			const ADEsentence & annotatedSent =annotated[sentIdx];
565 | 			string lastNerLabel = nullkey;
566 | 			vector<string> labelSequence;
567 | 
568 | 			vector<Entity> anwserEntities;
569 | 			vector<Relation> anwserRelations;
570 | 
571 | 			for(int tokenIdx=0;tokenIdx<sent.tokens.size();tokenIdx++) {
572 | 				const fox::Token& token = sent.tokens[tokenIdx];
573 | 
574 | 				Example eg(false);
575 | 				string fakeLabelName = "";
576 | 				generateOneNerExample(eg, fakeLabelName, sent, lastNerLabel, tokenIdx);
577 | 
578 | 				vector<dtype> probs;
579 | 				int predicted = m_classifier.predictNer(eg, probs);
580 | 
581 | 				string labelName = NERlabelID2labelName(predicted);
582 | 				labelSequence.push_back(labelName);
583 | 
584 | 				// decode entity label
585 | 				if(labelName == B_Disease || labelName == U_Disease ||
586 | 						labelName == B_Chemical || labelName == U_Chemical ) {
587 | 					Entity entity;
588 | 					newEntity(token, labelName, entity);
589 | 					anwserEntities.push_back(entity);
590 | 				} else if(labelName == I_Disease || labelName == L_Disease ||
591 | 						labelName == I_Chemical || labelName == L_Chemical ) {
592 | 					if(checkWrongState(labelSequence)) {
593 | 						Entity& entity = anwserEntities[anwserEntities.size()-1];
594 | 						appendEntity(token, entity);
595 | 					}
596 | 				}
597 | 
598 | 				lastNerLabel = labelName;
599 | 			} // token
600 | 
601 | 
602 | 			for(int bIdx=0;bIdx<anwserEntities.size();bIdx++) {
603 | 				const Entity& bEntity = anwserEntities[bIdx];
604 | 
605 | 				// a is before b
606 | 				for(int aIdx=0;aIdx<bIdx;aIdx++) {
607 | 					const Entity& aEntity = anwserEntities[aIdx];
608 | 
609 | 					// type constraint
610 | 					if(aEntity.type==bEntity.type)	{
611 | 						continue;
612 | 					}
613 | 
614 | 					const Entity& Disease = aEntity.type==TYPE_Disease? aEntity:bEntity;
615 | 					const Entity& Chemical = aEntity.type==TYPE_Disease? bEntity:aEntity;
616 | 
617 | 					Example eg(true);
618 | 					string fakeLabelName = "";
619 | 					generateOneRelExample(eg, fakeLabelName, sent, Disease, Chemical, labelSequence);
620 | 
621 | 					vector<dtype> probs;
622 | 					int predicted = m_classifier.predictRel(eg, probs);
623 | 
624 | 					string labelName = RellabelID2labelName(predicted);
625 | 
626 | 					// decode relation label
627 | 					if(labelName == ADE) {
628 | 						Relation relation;
629 | 						newRelation(relation, Disease, Chemical);
630 | 						anwserRelations.push_back(relation);
631 | 					}
632 | 
633 | 				} // aIdx
634 | 
635 | 			} // bIdx
636 | 
637 | 			// evaluate by ourselves
638 | 			ctGoldEntity += annotatedSent.entities.size();
639 | 			ctPredictEntity += anwserEntities.size();
640 | 			for(int i=0;i<anwserEntities.size();i++) {
641 | 				for(int j=0;j<annotatedSent.entities.size();j++) {
642 | 					if(anwserEntities[i].equals(annotatedSent.entities[j])) {
643 | 						ctCorrectEntity ++;
644 | 						break;
645 | 					}
646 | 				}
647 | 			}
648 | 
649 | 			ctGoldRelation += annotatedSent.relations.size();
650 | 			ctPredictRelation += anwserRelations.size();
651 | 			for(int i=0;i<anwserRelations.size();i++) {
652 | 				for(int j=0;j<annotatedSent.relations.size();j++) {
653 | 					if(anwserRelations[i].equals(annotatedSent.relations[j])) {
654 | 						ctCorrectRelation ++;
655 | 						break;
656 | 					}
657 | 				}
658 | 			}
659 | 
660 | 
661 | 		} // sent
662 | 
663 | 
664 | 		ret.test_pEntity = precision(ctCorrectEntity, ctPredictEntity);
665 | 		ret.test_rEntity = recall(ctCorrectEntity, ctGoldEntity);
666 | 		ret.test_f1Entity = f1(ctCorrectEntity, ctGoldEntity, ctPredictEntity);
667 | 		ret.test_pRelation = precision(ctCorrectRelation, ctPredictRelation);
668 | 		ret.test_rRelation = recall(ctCorrectRelation, ctGoldRelation);
669 | 		ret.test_f1Relation = f1(ctCorrectRelation, ctGoldRelation, ctPredictRelation);
670 | 
671 | 		cout<<"test entity p: "<<ret.test_pEntity<<", r:"<<ret.test_rEntity<<", f1:"<<ret.test_f1Entity<<endl;
672 | 		cout<<"test relation p: "<<ret.test_pRelation<<", r:"<<ret.test_rRelation<<", f1:"<<ret.test_f1Relation<<endl;
673 | 
674 | 
675 | 		return ret;
676 | 
677 | 
678 | 	}
679 | 
680 | 	// Only used when current label is I or L, check state from back to front
681 | 	// in case that "O I I", etc.
682 | 	bool checkWrongState(const vector<string>& labelSequence) {
683 | 		int positionNew = -1; // the latest type-consistent B
684 | 		int positionOther = -1; // other label except type-consistent I
685 | 
686 | 		const string& currentLabel = labelSequence[labelSequence.size()-1];
687 | 
688 | 		for(int j=labelSequence.size()-2;j>=0;j--) {
689 | 			if(currentLabel==I_Disease || currentLabel==L_Disease) {
690 | 				if(positionNew==-1 && labelSequence[j]==B_Disease) {
691 | 					positionNew = j;
692 | 				} else if(positionOther==-1 && labelSequence[j]!=I_Disease) {
693 | 					positionOther = j;
694 | 				}
695 | 			} else if(currentLabel==I_Chemical || currentLabel==L_Chemical) {
696 | 				if(positionNew==-1 && labelSequence[j]==B_Chemical) {
697 | 					positionNew = j;
698 | 				} else if(positionOther==-1 && labelSequence[j]!=I_Chemical) {
699 | 					positionOther = j;
700 | 				}
701 | 			}
702 | 
703 | 			if(positionOther!=-1 && positionNew!=-1)
704 | 				break;
705 | 		}
706 | 
707 | 		if(positionNew == -1)
708 | 			return false;
709 | 		else if(positionOther<positionNew)
710 | 			return true;
711 | 		else
712 | 			return false;
713 | 	}
714 | 
715 | 	void generateOneNerExample(Example& eg, const string& labelName, const fox::Sent& sent,
716 | 			const string& lastNerLabel, const int tokenIdx) {
717 | 		if(!labelName.empty()) {
718 | 			int labelID = NERlabelName2labelID(labelName);
719 | 			for(int i=0;i<MAX_ENTITY;i++)
720 | 				eg._nerLabels.push_back(0);
721 | 			eg._nerLabels[labelID] = 1;
722 | 			eg.nerGoldLabel = labelID;
723 | 
724 | 		}
725 | 
726 | 		for(int i=0;i<sent.tokens.size();i++) {
727 | 			eg._words.push_back(featureName2ID(m_wordAlphabet, feature_word(sent.tokens[i])));
728 | 			eg._postags.push_back(featureName2ID(m_posAlphabet, feature_pos(sent.tokens[i])));
729 | 			vector<int> chars;
730 | 			featureName2ID(m_charAlphabet, feature_character(sent.tokens[i]), chars);
731 | 			eg._seq_chars.push_back(chars);
732 | 		}
733 | 
734 | 		eg._prior_ner = featureName2ID(m_nerAlphabet, lastNerLabel);
735 | 		eg._current_idx = tokenIdx;
736 | 	}
737 | 
738 | 	void generateOneRelExample(Example& eg, const string& labelName, const fox::Sent& sent,
739 | 			const Entity& Disease, const Entity& Chemical, const vector<string>& labelSequence) {
740 | 		if(!labelName.empty()) {
741 | 			int labelID = RellabelName2labelID(labelName);
742 | 			for(int i=0;i<MAX_RELATION;i++)
743 | 				eg._relLabels.push_back(0);
744 | 			eg._relLabels[labelID] = 1;
745 | 			eg.relGoldLabel = labelID;
746 | 
747 | 		}
748 | 
749 | 		int bacTkEnd = -1;
750 | 		int locTkEnd = -1;
751 | 		const Entity& former = Disease.begin<Chemical.begin? Disease:Chemical;
752 | 		const Entity& latter = Disease.begin<Chemical.begin ? Chemical:Disease;
753 | 
754 | 		for(int i=0;i<sent.tokens.size();i++) {
755 | 			const fox::Token& token = sent.tokens[i];
756 | 
757 | 			eg._words.push_back(featureName2ID(m_wordAlphabet, feature_word(token)));
758 | 			eg._postags.push_back(featureName2ID(m_posAlphabet, feature_pos(token)));
759 | 			vector<int> chars;
760 | 			featureName2ID(m_charAlphabet, feature_character(sent.tokens[i]), chars);
761 | 			eg._seq_chars.push_back(chars);
762 | 			eg._deps.push_back(featureName2ID(m_depAlphabet, feature_dep(token)));
763 | 			eg._ners.push_back(featureName2ID(m_nerAlphabet, labelSequence[i]));
764 | 
765 | 			if(boolTokenInEntity(token, Disease)) {
766 | 				eg._idx_e1.insert(i);
767 | 
768 | 				// if like "Listeria sp.", "." is not in dependency tree
769 | 				if(bacTkEnd == -1 /*&& sent.tokens[i].depGov!=-1*/)
770 | 					bacTkEnd = i;
771 | 				else if(bacTkEnd < i /*&& sent.tokens[i].depGov!=-1*/)
772 | 					bacTkEnd = i;
773 | 			}
774 | 
775 | 			if(boolTokenInEntity(token, Chemical)) {
776 | 				eg._idx_e2.insert(i);
777 | 
778 | 				if(locTkEnd == -1 /*&& sent.tokens[i].depGov!=-1*/)
779 | 					locTkEnd = i;
780 | 				else if(locTkEnd < i /*&& sent.tokens[i].depGov!=-1*/)
781 | 					locTkEnd = i;
782 | 			}
783 | 
784 | 			if(isTokenBetweenTwoEntities(token, former, latter)) {
785 | 				eg._between_words.push_back(i);
786 | 			}
787 | 		}
788 | 
789 | 		if(eg._between_words.size()==0) {
790 | 			eg._between_words.push_back(featureName2ID(m_wordAlphabet, nullkey));
791 | 		}
792 | 
793 | 		assert(bacTkEnd!=-1);
794 | 		assert(locTkEnd!=-1);
795 | 
796 | 
797 | 		// use SDP based on the last word of the entity
798 | 		vector<int> sdpA;
799 | 		vector<int> sdpB;
800 | 		int common = fox::Dependency::getCommonAncestor(sent.tokens, bacTkEnd, locTkEnd,
801 | 				sdpA, sdpB);
802 | 
803 | 
804 | 		//assert(common!=-2); // no common ancestor
805 | 		assert(common!=-1); // common ancestor is root
806 | 
807 | 		if(common == -2) {
808 | 			eg._idxOnSDP_E12A.push_back(bacTkEnd);
809 | 			eg._idxOnSDP_E22A.push_back(locTkEnd);
810 | 		} else {
811 | 			for(int sdpANodeIdx=0;sdpANodeIdx<sdpA.size();sdpANodeIdx++) {
812 | 				eg._idxOnSDP_E12A.push_back(sdpA[sdpANodeIdx]-1);
813 | 			}
814 | 
815 | 			for(int sdpBNodeIdx=0;sdpBNodeIdx<sdpB.size();sdpBNodeIdx++) {
816 | 				eg._idxOnSDP_E22A.push_back(sdpB[sdpBNodeIdx]-1);
817 | 			}
818 | 		}
819 | 
820 | 
821 | 	}
822 | 
823 | 	void createAlphabet (vector<fox::Sent> & processed, Tool& tool) {
824 | 
825 | 		hash_map<string, int> word_stat;
826 | 		hash_map<string, int> pos_stat;
827 | 		hash_map<string, int> dep_stat;
828 | 		hash_map<string, int> char_stat;
829 | 
830 | 		for(int i=0;i<processed.size();i++) {
831 | 			fox::Sent & sent = processed[i];
832 | 
833 | 			for(int j=0;j<sent.tokens.size();j++) {
834 | 				string curword = feature_word(sent.tokens[j]);
835 | 				word_stat[curword]++;
836 | 
837 | 				string pos = feature_pos(sent.tokens[j]);
838 | 				pos_stat[pos]++;
839 | 
840 | 				vector<string> characters = feature_character(sent.tokens[j]);
841 | 				for(int i=0;i<characters.size();i++)
842 | 					char_stat[characters[i]]++;
843 | 
844 | 				string dep = feature_dep(sent.tokens[j]);
845 | 				dep_stat[dep]++;
846 | 			}
847 | 
848 | 		}
849 | 
850 | 
851 | 		stat2Alphabet(word_stat, m_wordAlphabet, "word");
852 | 
853 | 		stat2Alphabet(pos_stat, m_posAlphabet, "pos");
854 | 
855 | 		stat2Alphabet(dep_stat, m_depAlphabet, "dep");
856 | 
857 | 		stat2Alphabet(char_stat, m_charAlphabet, "char");
858 | 	}
859 | 
860 | 	string feature_word(const fox::Token& token) {
861 | 		string ret = normalize_to_lowerwithdigit(token.word);
862 | 		//string ret = normalize_to_lowerwithdigit(token.lemma);
863 | 
864 | 		return ret;
865 | 	}
866 | 
867 | 
868 | 	string feature_pos(const fox::Token& token) {
869 | 		return token.pos;
870 | 	}
871 | 
872 | 	string feature_dep(const fox::Token& token) {
873 | 		return token.depType;
874 | 	}
875 | 
876 | 	vector<string> feature_character(const fox::Token& token) {
877 | 		vector<string> ret;
878 | 		string word = feature_word(token);
879 | 		for(int i=0;i<word.length();i++)
880 | 			ret.push_back(word.substr(i, 1));
881 | 		return ret;
882 | 	}
883 | 
884 | 	void randomInitNrmat(NRMat<dtype>& nrmat, Alphabet& alphabet, int embSize, int seed) {
885 | 		double* emb = new double[alphabet.size()*embSize];
886 | 		fox::initArray2((double *)emb, (int)alphabet.size(), embSize, 0.0);
887 | 
888 | 		vector<string> known;
889 | 		map<string, int> IDs;
890 | 		alphabet2vectormap(alphabet, known, IDs);
891 | 
892 | 		fox::randomInitEmb((double*)emb, embSize, known, unknownkey,
893 | 				IDs, false, m_options.initRange, seed);
894 | 
895 | 		nrmat.resize(alphabet.size(), embSize);
896 | 		array2NRMat((double*) emb, alphabet.size(), embSize, nrmat);
897 | 
898 | 		delete[] emb;
899 | 	}
900 | 
901 | 	template<typename xpu>
902 | 	void averageUnkownEmb(Alphabet& alphabet, LookupTable<xpu>& table, int embSize) {
903 | 
904 | 		// unknown cannot be trained, use the average embedding
905 | 		int unknownID = alphabet.from_string(unknownkey);
906 | 		Tensor<cpu, 2, dtype> temp = NewTensor<cpu>(Shape2(1, embSize), d_zero);
907 | 		int number = table._nVSize-1;
908 | 		table._E[unknownID] = 0.0;
909 | 		for(int i=0;i<table._nVSize;i++) {
910 | 			if(i==unknownID)
911 | 				continue;
912 | 			table.GetEmb(i, temp);
913 | 			table._E[unknownID] += temp[0]/number;
914 | 		}
915 | 
916 | 		FreeSpace(&temp);
917 | 
918 | 	}
919 | 
920 | 	void stat2Alphabet(hash_map<string, int>& stat, Alphabet& alphabet, const string& label) {
921 | 
922 | 		cout << label<<" num: " << stat.size() << endl;
923 | 		alphabet.set_fixed_flag(false);
924 | 		hash_map<string, int>::iterator feat_iter;
925 | 		for (feat_iter = stat.begin(); feat_iter != stat.end(); feat_iter++) {
926 | 			// if not fine tune, add all the words; if fine tune, add the words considering wordCutOff
927 | 			// in order to train unknown
928 | 			if (!m_options.wordEmbFineTune || feat_iter->second > m_options.wordCutOff) {
929 | 			  alphabet.from_string(feat_iter->first);
930 | 			}
931 | 		}
932 | 		cout << "alphabet "<< label<<" num: " << alphabet.size() << endl;
933 | 		alphabet.set_fixed_flag(true);
934 | 
935 | 	}
936 | 
937 | 
938 | 	void featureName2ID(Alphabet& alphabet, const string& featureName, vector<int>& vfeatureID) {
939 | 		int id = alphabet.from_string(featureName);
940 | 		if(id >=0)
941 | 			vfeatureID.push_back(id);
942 | 		else
943 | 			vfeatureID.push_back(0); // assume unknownID is zero
944 | 	}
945 | 
946 | 	void featureName2ID(Alphabet& alphabet, const vector<string>& featureName, vector<int>& vfeatureID) {
947 | 		for(int i=0;i<featureName.size();i++) {
948 | 			int id = alphabet.from_string(featureName[i]);
949 | 			if(id >=0)
950 | 				vfeatureID.push_back(id);
951 | 			else
952 | 				vfeatureID.push_back(0); // assume unknownID is zero
953 | 		}
954 | 	}
955 | 
956 | 	int featureName2ID(Alphabet& alphabet, const string& featureName) {
957 | 		int id = alphabet.from_string(featureName);
958 | 		if(id >=0)
959 | 			return id;
960 | 		else
961 | 			return 0; // assume unknownID is zero
962 | 	}
963 | 
964 | };
965 | 
966 | 
967 | 
968 | #endif /* NNBB3_H_ */
969 | 
970 | 


--------------------------------------------------------------------------------