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 }