001 package org.maltparser.parser.guide.decision;
002
003 import org.maltparser.core.exception.MaltChainedException;
004 import org.maltparser.core.feature.FeatureModel;
005 import org.maltparser.core.feature.FeatureVector;
006 import org.maltparser.core.syntaxgraph.DependencyStructure;
007 import org.maltparser.parser.DependencyParserConfig;
008 import org.maltparser.parser.guide.ClassifierGuide;
009 import org.maltparser.parser.guide.GuideException;
010 import org.maltparser.parser.guide.instance.AtomicModel;
011 import org.maltparser.parser.guide.instance.DecisionTreeModel;
012 import org.maltparser.parser.guide.instance.FeatureDivideModel;
013 import org.maltparser.parser.guide.instance.InstanceModel;
014 import org.maltparser.parser.history.action.GuideDecision;
015 import org.maltparser.parser.history.action.MultipleDecision;
016 import org.maltparser.parser.history.action.SingleDecision;
017 /**
018 *
019 * @author Johan Hall
020 * @since 1.1
021 **/
022 public class OneDecisionModel implements DecisionModel {
023 private ClassifierGuide guide;
024 private String modelName;
025 private FeatureModel featureModel;
026 private InstanceModel instanceModel;
027 private int decisionIndex;
028 private DecisionModel prevDecisionModel;
029 private String branchedDecisionSymbols;
030 private int nIteration;
031
032
033 public OneDecisionModel(ClassifierGuide guide, FeatureModel featureModel) throws MaltChainedException {
034 this.branchedDecisionSymbols = "";
035 setGuide(guide);
036 setFeatureModel(featureModel);
037 setDecisionIndex(0);
038 if (guide.getGuideName() == null || guide.getGuideName().equals("")) {
039 setModelName("odm"+decisionIndex);
040 } else {
041 setModelName(guide.getGuideName()+".odm"+decisionIndex);
042 }
043
044 setPrevDecisionModel(null);
045 }
046
047 public OneDecisionModel(ClassifierGuide guide, DecisionModel prevDecisionModel, String branchedDecisionSymbol) throws MaltChainedException {
048 if (branchedDecisionSymbol != null && branchedDecisionSymbol.length() > 0) {
049 this.branchedDecisionSymbols = branchedDecisionSymbol;
050 } else {
051 this.branchedDecisionSymbols = "";
052 }
053 setGuide(guide);
054 setFeatureModel(prevDecisionModel.getFeatureModel());
055 setDecisionIndex(prevDecisionModel.getDecisionIndex() + 1);
056 setPrevDecisionModel(prevDecisionModel);
057 if (branchedDecisionSymbols != null && branchedDecisionSymbols.length() > 0) {
058 setModelName("odm"+decisionIndex+branchedDecisionSymbols);
059 } else {
060 setModelName("odm"+decisionIndex);
061 }
062 }
063
064 public void updateFeatureModel() throws MaltChainedException {
065 featureModel.update();
066 }
067
068 public void updateCardinality() throws MaltChainedException {
069 featureModel.updateCardinality();
070 }
071
072
073 public void finalizeSentence(DependencyStructure dependencyGraph) throws MaltChainedException {
074 if (instanceModel != null) {
075 instanceModel.finalizeSentence(dependencyGraph);
076 }
077 }
078
079 public void noMoreInstances() throws MaltChainedException {
080 if (guide.getGuideMode() == ClassifierGuide.GuideMode.CLASSIFY) {
081 throw new GuideException("The decision model could not create it's model. ");
082 }
083 featureModel.updateCardinality();
084 if (instanceModel != null) {
085 instanceModel.noMoreInstances();
086 instanceModel.train();
087 }
088 }
089
090 public void terminate() throws MaltChainedException {
091 if (instanceModel != null) {
092 instanceModel.terminate();
093 instanceModel = null;
094 }
095 }
096
097 public void addInstance(GuideDecision decision) throws MaltChainedException {
098 updateFeatureModel();
099 final SingleDecision singleDecision = (decision instanceof SingleDecision)?(SingleDecision)decision:((MultipleDecision)decision).getSingleDecision(decisionIndex);
100
101 if (instanceModel == null) {
102 initInstanceModel(singleDecision.getTableContainer().getTableContainerName());
103 }
104 instanceModel.addInstance(singleDecision);
105 }
106
107 public boolean predict(GuideDecision decision) throws MaltChainedException {
108 updateFeatureModel();
109 final SingleDecision singleDecision = (decision instanceof SingleDecision)?(SingleDecision)decision:((MultipleDecision)decision).getSingleDecision(decisionIndex);
110
111 if (instanceModel == null) {
112 initInstanceModel(singleDecision.getTableContainer().getTableContainerName());
113 }
114 return instanceModel.predict(singleDecision);
115 }
116
117 public FeatureVector predictExtract(GuideDecision decision) throws MaltChainedException {
118 updateFeatureModel();
119 final SingleDecision singleDecision = (decision instanceof SingleDecision)?(SingleDecision)decision:((MultipleDecision)decision).getSingleDecision(decisionIndex);
120
121 if (instanceModel == null) {
122 initInstanceModel(singleDecision.getTableContainer().getTableContainerName());
123 }
124 return instanceModel.predictExtract(singleDecision);
125 }
126
127 public FeatureVector extract() throws MaltChainedException {
128 updateFeatureModel();
129 return instanceModel.extract();
130 }
131
132 public boolean predictFromKBestList(GuideDecision decision) throws MaltChainedException {
133 if (decision instanceof SingleDecision) {
134 return ((SingleDecision)decision).updateFromKBestList();
135 } else {
136 return ((MultipleDecision)decision).getSingleDecision(decisionIndex).updateFromKBestList();
137 }
138 }
139
140 public ClassifierGuide getGuide() {
141 return guide;
142 }
143
144 public String getModelName() {
145 return modelName;
146 }
147
148 public FeatureModel getFeatureModel() {
149 return featureModel;
150 }
151
152 public int getDecisionIndex() {
153 return decisionIndex;
154 }
155
156 public DecisionModel getPrevDecisionModel() {
157 return prevDecisionModel;
158 }
159
160 private void setPrevDecisionModel(DecisionModel prevDecisionModel) {
161 this.prevDecisionModel = prevDecisionModel;
162 }
163
164 private void setFeatureModel(FeatureModel featureModel) {
165 this.featureModel = featureModel;
166 }
167
168 private void setDecisionIndex(int decisionIndex) {
169 this.decisionIndex = decisionIndex;
170 }
171
172 private void setModelName(String modelName) {
173 this.modelName = modelName;
174 }
175
176 private void setGuide(ClassifierGuide guide) {
177 this.guide = guide;
178 }
179
180 private final void initInstanceModel(String subModelName) throws MaltChainedException {
181 FeatureVector fv = featureModel.getFeatureVector(branchedDecisionSymbols+"."+subModelName);
182 if (fv == null) {
183 fv = featureModel.getFeatureVector(subModelName);
184 }
185 if (fv == null) {
186 fv = featureModel.getMainFeatureVector();
187 }
188 DependencyParserConfig c = guide.getConfiguration();
189
190 // if (c.getOptionValue("guide", "tree_automatic_split_order").toString().equals("yes") ||
191 // (c.getOptionValue("guide", "tree_split_columns")!=null &&
192 // c.getOptionValue("guide", "tree_split_columns").toString().length() > 0) ||
193 // (c.getOptionValue("guide", "tree_split_structures")!=null &&
194 // c.getOptionValue("guide", "tree_split_structures").toString().length() > 0)) {
195 // instanceModel = new DecisionTreeModel(fv, this);
196 // }else
197 if (c.getOptionValue("guide", "data_split_column").toString().length() == 0) {
198 instanceModel = new AtomicModel(-1, fv, this);
199 } else {
200 instanceModel = new FeatureDivideModel(fv, this);
201 }
202 }
203
204 public String toString() {
205 return modelName;
206 }
207 }