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