public object Clone() { Parse clonedParse = (Parse)base.MemberwiseClone(); clonedParse.mParts = new List <Parse>(mParts); if (mDerivation != null) { clonedParse.InitializeDerivationBuffer(); clonedParse.AppendDerivationBuffer(mDerivation.ToString()); } return(clonedParse); }
///<summary> ///Advances the specified parse and returns the an array advanced parses whose probability accounts for ///more than the speicficed amount of probability mass, Q. ///</summary> ///<param name="inputParse"> ///The parse to advance. ///</param> ///<param name="qParam"> ///The amount of probability mass that should be accounted for by the advanced parses. ///</param> private Parse[] AdvanceParses(Parse inputParse, double qParam, double[] buildProbabilities, double[] checkProbabilities) { double qOpp = 1 - qParam; Parse lastStartNode = null; // The closest previous node which has been labeled as a start node. int lastStartIndex = -1; // The index of the closest previous node which has been labeled as a start node. string lastStartType = null; // The type of the closest previous node which has been labeled as a start node. int advanceNodeIndex; // The index of the node which will be labeled in this iteration of advancing the parse. Parse advanceNode = null; // The node which will be labeled in this iteration of advancing the parse. Parse[] children = inputParse.GetChildren(); int nodeCount = children.Length; //determines which node needs to be labeled and prior labels. for (advanceNodeIndex = 0; advanceNodeIndex < nodeCount; advanceNodeIndex++) { advanceNode = children[advanceNodeIndex]; if (advanceNode.Label == null) { break; } else if (startTypeMap.ContainsKey(advanceNode.Label)) { lastStartType = startTypeMap[advanceNode.Label]; lastStartNode = advanceNode; lastStartIndex = advanceNodeIndex; } } var newParsesList = new List <Parse>(buildModel.OutcomeCount); //call build buildModel.Evaluate(buildContextGenerator.GetContext(children, advanceNodeIndex), buildProbabilities); double buildProbabilitiesSum = 0; while (buildProbabilitiesSum < qParam) { // The largest unadvanced labeling. int highestBuildProbabilityIndex = 0; for (int probabilityIndex = 1; probabilityIndex < buildProbabilities.Length; probabilityIndex++) { //for each build outcome if (buildProbabilities[probabilityIndex] > buildProbabilities[highestBuildProbabilityIndex]) { highestBuildProbabilityIndex = probabilityIndex; } } if (buildProbabilities[highestBuildProbabilityIndex] == 0) { break; } double highestBuildProbability = buildProbabilities[highestBuildProbabilityIndex]; buildProbabilities[highestBuildProbabilityIndex] = 0; //zero out so new max can be found buildProbabilitiesSum += highestBuildProbability; string tag = buildModel.GetOutcomeName(highestBuildProbabilityIndex); //System.Console.Out.WriteLine("trying " + tag + " " + buildProbabilitiesSum + " lst=" + lst); if (highestBuildProbabilityIndex == topStartIndex) { // can't have top until complete continue; } //System.Console.Error.WriteLine(probabilityIndex + " " + tag + " " + highestBuildProbability); if (startTypeMap.ContainsKey(tag)) { //update last start lastStartIndex = advanceNodeIndex; lastStartNode = advanceNode; lastStartType = startTypeMap[tag]; } else if (continueTypeMap.ContainsKey(tag)) { if (lastStartNode == null || lastStartType != continueTypeMap[tag]) { continue; //Cont must match previous start or continue } } var newParse1 = (Parse)inputParse.Clone(); //clone parse if (CreateDerivationString) { newParse1.AppendDerivationBuffer(highestBuildProbabilityIndex.ToString(System.Globalization.CultureInfo.InvariantCulture)); newParse1.AppendDerivationBuffer("-"); } newParse1.SetChild(advanceNodeIndex, tag); //replace constituent labeled newParse1.AddProbability(Math.Log(highestBuildProbability)); //check checkModel.Evaluate(checkContextGenerator.GetContext(newParse1.GetChildren(), lastStartType, lastStartIndex, advanceNodeIndex), checkProbabilities); //System.Console.Out.WriteLine("check " + mCheckProbabilities[mCompleteIndex] + " " + mCheckProbabilities[mIncompleteIndex]); Parse newParse2 = newParse1; if (checkProbabilities[completeIndex] > qOpp) { //make sure a reduce is likely newParse2 = (Parse)newParse1.Clone(); if (CreateDerivationString) { newParse2.AppendDerivationBuffer("1"); newParse2.AppendDerivationBuffer("."); } newParse2.AddProbability(System.Math.Log(checkProbabilities[1])); var constituent = new Parse[advanceNodeIndex - lastStartIndex + 1]; bool isFlat = true; //first constituent[0] = lastStartNode; if (constituent[0].Type != constituent[0].Head.Type) { isFlat = false; } //last constituent[advanceNodeIndex - lastStartIndex] = advanceNode; if (isFlat && constituent[advanceNodeIndex - lastStartIndex].Type != constituent[advanceNodeIndex - lastStartIndex].Head.Type) { isFlat = false; } //middle for (int constituentIndex = 1; constituentIndex < advanceNodeIndex - lastStartIndex; constituentIndex++) { constituent[constituentIndex] = children[constituentIndex + lastStartIndex]; if (isFlat && constituent[constituentIndex].Type != constituent[constituentIndex].Head.Type) { isFlat = false; } } if (!isFlat) { //flat chunks are done by chunker newParse2.Insert(new Parse(inputParse.Text, new Util.Span(lastStartNode.Span.Start, advanceNode.Span.End), lastStartType, checkProbabilities[1], headRules.GetHead(constituent, lastStartType))); newParsesList.Add(newParse2); } } if (checkProbabilities[incompleteIndex] > qOpp) { //make sure a shift is likely if (CreateDerivationString) { newParse1.AppendDerivationBuffer("0"); newParse1.AppendDerivationBuffer("."); } if (advanceNodeIndex != nodeCount - 1) { //can't shift last element newParse1.AddProbability(Math.Log(checkProbabilities[0])); newParsesList.Add(newParse1); } } } Parse[] newParses = newParsesList.ToArray(); return(newParses); }