public UnaryRule Clone() { var clone = new UnaryRule (); clone.ptag = ptag; clone.ctag = ctag; clone.scores = ArrayHelper.Clone (scores); return clone; }
public UnaryRule SplitSymbols(int[] subtagCount, int[] newSubtagCount, Random RNG, double randomness) { int parentSplitFactor = subtagCount [ptag] == newSubtagCount [ptag] ? 1 : 2; int childSplitFactor = subtagCount [ctag] == newSubtagCount [ctag] ? 1 : 2; double[][] oldScores = scores; double[][] newScores = new double[newSubtagCount [ctag]][]; for (int csubt = 0; csubt < oldScores.Length; ++csubt) { if (oldScores [csubt] == null) { continue; } for (int offset = 0; offset < childSplitFactor; ++offset) { newScores [childSplitFactor * csubt + offset] = new double[newSubtagCount [ptag]]; } for (int psubt = 0; psubt < subtagCount[ptag]; ++psubt) { double score = oldScores [csubt] [psubt]; for (int p = 0; p < parentSplitFactor; ++p) { double div = (double)Math.Log (childSplitFactor); double rd = (double)(randomness / 100 * (RNG.NextDouble () - 0.5)); int newPsubt = psubt * parentSplitFactor + p; if (childSplitFactor == 1) { rd = 0; } for (int c = 0; c < childSplitFactor; ++c) { rd *= -1.0f; int newCsubt = csubt * childSplitFactor + c; newScores [newCsubt] [newPsubt] = score - div + (double)Math.Log (1.0f + rd); } } } } var newRule = new UnaryRule (newScores, ptag, ctag); return newRule; }
public UnaryRule CreateRule(int[] newSubtagCount) { var rule = new UnaryRule (); rule.scores = ArrayHelper.AllocateArray<double> (newSubtagCount [ctag], newSubtagCount [ptag]); ArrayHelper.Fill (rule.scores, double.NegativeInfinity); rule.ptag = ptag; rule.ctag = ctag; return rule; }
public UnaryRule MergeSymbols(int[][] trace, double[][] symbolProbs, double[][] projectedSymbolProbs) { int ptagcount = trace [ptag] [trace [ptag].Length - 1] + 1; int ctagcount = trace [ctag] [trace [ctag].Length - 1] + 1; var newScores = ArrayHelper.AllocateArray<double> (ctagcount, ptagcount); ArrayHelper.Fill<double> (newScores, double.NegativeInfinity); for (int c = 0; c < scores.Length; ++c) { if (scores [c] == null) { continue; } int pc = trace [ctag] [c]; for (int p = 0; p < scores[c].Length; ++p) { int pp = trace [ptag] [p]; newScores [pc] [pp] = MathHelper.LogAdd (newScores [pc] [pp], scores [c] [p] + symbolProbs [ptag] [p]); } } for (int pc = 0; pc < newScores.Length; ++pc) { for (int pp = 0; pp < newScores[pc].Length; ++pp) { if (!double.IsNegativeInfinity (newScores [pc] [pp]) && !double.IsNegativeInfinity (projectedSymbolProbs [ptag] [pp])) { newScores [pc] [pp] -= projectedSymbolProbs [ptag] [pp]; } } } var rule = new UnaryRule (); rule.ptag = ptag; rule.ctag = ctag; rule.scores = newScores; return rule; }
public void CopyTo(UnaryRule rule) { rule.ctag = ctag; rule.ptag = ptag; ArrayHelper.CopyTo (scores, rule.scores); }
public LAPCFGrammar(TagSet set, double[][][] brawScores, double[][] urawScores, double[][] trawScores) { NTCount = set.NTCount; PTCount = set.PTCount; ROOTID = set.ROOTID; var tagCount = TotalTagCount; brules = new BinaryRule[tagCount][][]; for (int l = 0; l < tagCount; ++l) { if (brawScores [l] == null) { continue; } brules [l] = new BinaryRule[tagCount][]; for (int r = 0; r < tagCount; ++r) { if (brawScores [l] [r] == null) { continue; } brules [l] [r] = new BinaryRule[tagCount]; for (int p = 0; p < tagCount; ++p) { if (!double.IsInfinity(brawScores [l] [r] [p]) && !double.IsNaN(brawScores [l] [r] [p])) { double[][][] s = new double[1][][]; s [0] = new double[1][]; s [0] [0] = new double[1]; s [0] [0] [0] = brawScores [l] [r] [p]; brules [l] [r] [p] = new BinaryRule(s, p, l, r); } } } } urules = new UnaryRule[tagCount][]; for (int c = 0; c < tagCount; ++c) { if (urawScores [c] == null) { continue; } urules [c] = new UnaryRule[tagCount]; for (int p = 0; p < tagCount; ++p) { if (!double.IsNaN(urawScores [c] [p]) && !double.IsInfinity(urawScores [c] [p])) { double[][] s = new double[1][]; s [0] = new double[1]; s [0] [0] = urawScores [c] [p]; urules [c] [p] = new UnaryRule(s, p, c); } } } trules = new TerminalRule[trawScores.Length][]; for (int w = 0; w < trawScores.Length; ++w) { if (trawScores [w] == null) { continue; } trules [w] = new TerminalRule[trawScores [w].Length]; for (int t = 0; t < trules[w].Length; ++t) { if (!double.IsNaN(trawScores [w] [t]) && !double.IsInfinity(trawScores [w] [t])) { double[] s = new double[1]; s [0] = trawScores [w] [t]; trules [w] [t] = new TerminalRule(s, t, w); } } } subTagCounts = new int[tagCount]; for (int i = 0; i < subTagCounts.Length; ++i) { subTagCounts [i] = 1; } }
public static UnaryRule[][] CloneRules(UnaryRule[][] rules) { if (rules == null) { return null; } return rules.Select( x => x == null ? null : x.Select( y => y == null ? null : y.Clone() ).ToArray() ).ToArray(); }
private void BuildUnaryRule(string ruleString, TagSet tagSet) { string[] parts = ruleString.Split(new string[] { "\t", "_" }, StringSplitOptions.RemoveEmptyEntries); int ptag = tagSet.GetID(parts [0]); int subptag = int.Parse(parts [1]); int ctag = tagSet.GetID(parts [2]); int subctag = int.Parse(parts [3]); double s = double.Parse(parts [4]); if (urules == null) { urules = new UnaryRule[TotalTagCount][]; } if (urules [ctag] == null) { urules [ctag] = new UnaryRule[TotalTagCount]; } if (urules [ctag] [ptag] == null) { urules [ctag] [ptag] = new UnaryRule(ArrayHelper.AllocateArray<double>(subTagCounts [ctag], subTagCounts [ptag]), ptag, ctag); urules [ctag] [ptag].ClearScore(); } urules [ctag] [ptag].scores [subctag] [subptag] = s; }
public void PropMaxUnaryPath() { UnaryRule[][] xrules = ArrayHelper.AllocateArray<UnaryRule>(TotalTagCount, TotalTagCount); for (int c = 0; c < xrules.Length; ++c) { for (int p = 0; p < xrules[c].Length; ++p) { double[][] score = ArrayHelper.AllocateArray<double>(subTagCounts[c], subTagCounts[p]); ArrayHelper.Fill(score, double.NegativeInfinity); xrules[c][p] = new UnaryRule(score, p, c); } } CopyRules(urules, xrules); var prules = CloneRules(xrules); for (int tag = 0; tag < TotalTagCount; ++tag) { for (int subtag = 0; subtag < subTagCounts[tag]; ++subtag) { for (int ctag = 0; ctag < TotalTagCount; ++ctag) { for (int ptag = 0; ptag < TotalTagCount; ++ptag) { var rule = xrules[ctag][ptag]; var prule = prules[tag][ptag]; var crule = prules[ctag][tag]; for (int subctag = 0; subctag < subTagCounts[ctag]; ++subctag) { for (int subptag = 0; subptag < subTagCounts[ptag]; ++subptag) { double pscore = prule.scores[subtag][subptag]; double cscore = crule.scores[subctag][subtag]; if (double.IsNegativeInfinity(pscore) || double.IsNegativeInfinity(cscore)) { continue; } rule.scores[subctag][subptag] = Math.Max(rule.scores[subctag][subptag], pscore + cscore); } } } } CopyRules(xrules, prules); } } for (int c = 0; c < TotalTagCount; ++c) { int survive = 0; for (int p = 0; p < TotalTagCount; ++p) { xrules[c][p].ComputeMaxScore(); if (double.IsNegativeInfinity(xrules[c][p].maxScore)) { xrules[c][p] = null; } else { survive += 1; } } if (survive == 0) { xrules[c] = null; } } urules = xrules; }