public SimulatedAnnealingSearch(IToDoubleFunction <Node <S, A> > h, Scheduler scheduler, NodeExpander <S, A> nodeExpander) { this.h = h; this.scheduler = scheduler; this.nodeExpander = nodeExpander; nodeExpander.addNodeListener((node) => metrics.incrementInt(METRIC_NODES_EXPANDED)); }
/** Modifies the evaluation function if it is a {@link HeuristicEvaluationFunction}. */ public void setHeuristicFunction(IToDoubleFunction <Node <S, A> > h) { if (evalFn is HeuristicEvaluationFunction <S, A> ) { ((HeuristicEvaluationFunction <S, A>)evalFn).setHeuristicFunction(h); } }
public RecursiveBestFirstSearch(IToDoubleFunction <Node <S, A> > evalFn, bool avoidLoops, NodeExpander <S, A> nodeExpander) { this.evalFn = evalFn; this.avoidLoops = avoidLoops; this.nodeExpander = nodeExpander; nodeExpander.addNodeListener((node) => metrics.incrementInt(METRIC_NODES_EXPANDED)); metrics = new Metrics(); }
/// <summary>This computes the average over all folds of the function we're trying to optimize.</summary> /// <remarks> /// This computes the average over all folds of the function we're trying to optimize. /// The input triple contains, in order, the train set, the test set, and the saved state. /// You don't have to use the saved state if you don't want to. /// </remarks> public virtual double ComputeAverage(IToDoubleFunction <Triple <GeneralDataset <L, F>, GeneralDataset <L, F>, CrossValidator.SavedState> > function) { double sum = 0; IEnumerator <Triple <GeneralDataset <L, F>, GeneralDataset <L, F>, CrossValidator.SavedState> > foldIt = Iterator(); while (foldIt.MoveNext()) { sum += function.ApplyAsDouble(foldIt.Current); } return(sum / kFold); }
public void testHeuristicCalculation() { IToDoubleFunction <Node <EightPuzzleBoard, IAction> > h = EightPuzzleFunctions.createMisplacedTileHeuristicFunction(); EightPuzzleBoard board = new EightPuzzleBoard(new int[] { 2, 0, 5, 6, 4, 8, 3, 7, 1 }); Assert.AreEqual(6.0, h.applyAsDouble(new Node <EightPuzzleBoard, IAction>(board)), 0.001); board = new EightPuzzleBoard(new int[] { 6, 2, 5, 3, 4, 8, 0, 7, 1 }); Assert.AreEqual(5.0, h.applyAsDouble(new Node <EightPuzzleBoard, IAction>(board)), 0.001); board = new EightPuzzleBoard(new int[] { 6, 2, 5, 3, 4, 8, 7, 0, 1 }); Assert.AreEqual(6.0, h.applyAsDouble(new Node <EightPuzzleBoard, IAction>(board)), 0.001); board = new EightPuzzleBoard(new int[] { 8, 1, 2, 3, 4, 5, 6, 7, 0 }); Assert.AreEqual(1.0, h.applyAsDouble(new Node <EightPuzzleBoard, IAction>(board)), 0.001); board = new EightPuzzleBoard(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }); Assert.AreEqual(0.0, h.applyAsDouble(new Node <EightPuzzleBoard, IAction>(board)), 0.001); }
public static T GetBestMatched <T>(IList <T> matches, IToDoubleFunction <MatchedExpression> scorer) where T : MatchedExpression { if (matches == null || matches.IsEmpty()) { return(null); } T best = null; double bestScore = double.NegativeInfinity; foreach (T m in matches) { double s = scorer.ApplyAsDouble(m); if (best == null || s > bestScore) { best = m; bestScore = s; } } return(best); }
/** * Sets the heuristic function of this agent. * * @param h * heuristic function <em>h(n)</em>, which estimates the cost of * the cheapest path from the state at node <em>n</em> to a goal * state. */ public void setHeuristicFunction(IToDoubleFunction <S> h) { this.h = h; }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> internal virtual ICounter <E> Convert2OneDim(string label, IToDoubleFunction <Pair <E, CandidatePhrase> > scoringFunction, ICollection <CandidatePhrase> allCandidatePhrases, TwoDimensionalCounter <E, CandidatePhrase> positivePatternsAndWords, bool sqrtPatScore, bool scorePhrasesInPatSelection, ICounter <CandidatePhrase> dictOddsWordWeights, bool useFreqPhraseExtractedByPat) { // if (Data.googleNGram.size() == 0 && Data.googleNGramsFile != null) { // Data.loadGoogleNGrams(); // } ICounter <E> patterns = new ClassicCounter <E>(); ICounter <CandidatePhrase> googleNgramNormScores = new ClassicCounter <CandidatePhrase>(); ICounter <CandidatePhrase> domainNgramNormScores = new ClassicCounter <CandidatePhrase>(); ICounter <CandidatePhrase> externalFeatWtsNormalized = new ClassicCounter <CandidatePhrase>(); ICounter <CandidatePhrase> editDistanceFromOtherSemanticBinaryScores = new ClassicCounter <CandidatePhrase>(); ICounter <CandidatePhrase> editDistanceFromAlreadyExtractedBinaryScores = new ClassicCounter <CandidatePhrase>(); double externalWtsDefault = 0.5; ICounter <string> classifierScores = null; if ((patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPat) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPatLogP)) && scorePhrasesInPatSelection) { foreach (CandidatePhrase gc in allCandidatePhrases) { string g = gc.GetPhrase(); if (constVars.usePatternEvalEditDistOther) { editDistanceFromOtherSemanticBinaryScores.SetCount(gc, constVars.GetEditDistanceScoresOtherClassThreshold(label, g)); } if (constVars.usePatternEvalEditDistSame) { editDistanceFromAlreadyExtractedBinaryScores.SetCount(gc, 1 - constVars.GetEditDistanceScoresThisClassThreshold(label, g)); } if (constVars.usePatternEvalGoogleNgram) { googleNgramNormScores.SetCount(gc, PhraseScorer.GetGoogleNgramScore(gc)); } if (constVars.usePatternEvalDomainNgram) { // calculate domain-ngram wts if (Data.domainNGramRawFreq.ContainsKey(g)) { System.Diagnostics.Debug.Assert((Data.rawFreq.ContainsKey(gc))); domainNgramNormScores.SetCount(gc, scorePhrases.phraseScorer.GetDomainNgramScore(g)); } } if (constVars.usePatternEvalWordClass) { int num = constVars.GetWordClassClusters()[g]; if (num == null) { num = constVars.GetWordClassClusters()[g.ToLower()]; } if (num != null && constVars.distSimWeights[label].ContainsKey(num)) { externalFeatWtsNormalized.SetCount(gc, constVars.distSimWeights[label].GetCount(num)); } else { externalFeatWtsNormalized.SetCount(gc, externalWtsDefault); } } } if (constVars.usePatternEvalGoogleNgram) { googleNgramNormScores = GetPatternsFromDataMultiClass.NormalizeSoftMaxMinMaxScores(googleNgramNormScores, true, true, false); } if (constVars.usePatternEvalDomainNgram) { domainNgramNormScores = GetPatternsFromDataMultiClass.NormalizeSoftMaxMinMaxScores(domainNgramNormScores, true, true, false); } if (constVars.usePatternEvalWordClass) { externalFeatWtsNormalized = GetPatternsFromDataMultiClass.NormalizeSoftMaxMinMaxScores(externalFeatWtsNormalized, true, true, false); } } else { if ((patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.Logreg) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.LOGREGlogP)) && scorePhrasesInPatSelection) { Properties props2 = new Properties(); props2.PutAll(props); props2.SetProperty("phraseScorerClass", "edu.stanford.nlp.patterns.ScorePhrasesLearnFeatWt"); ScorePhrases scoreclassifier = new ScorePhrases(props2, constVars); System.Console.Out.WriteLine("file is " + props.GetProperty("domainNGramsFile")); ArgumentParser.FillOptions(typeof(Data), props2); classifierScores = scoreclassifier.phraseScorer.ScorePhrases(label, allCandidatePhrases, true); } } ICounter <CandidatePhrase> cachedScoresForThisIter = new ClassicCounter <CandidatePhrase>(); foreach (KeyValuePair <E, ClassicCounter <CandidatePhrase> > en in positivePatternsAndWords.EntrySet()) { foreach (KeyValuePair <CandidatePhrase, double> en2 in en.Value.EntrySet()) { CandidatePhrase word = en2.Key; ICounter <ConstantsAndVariables.ScorePhraseMeasures> scoreslist = new ClassicCounter <ConstantsAndVariables.ScorePhraseMeasures>(); double score = 1; if ((patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPat) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPatLogP)) && scorePhrasesInPatSelection) { if (cachedScoresForThisIter.ContainsKey(word)) { score = cachedScoresForThisIter.GetCount(word); } else { if (constVars.GetOtherSemanticClassesWords().Contains(word) || constVars.GetCommonEngWords().Contains(word)) { score = 1; } else { if (constVars.usePatternEvalSemanticOdds) { double semanticClassOdds = 1; if (dictOddsWordWeights.ContainsKey(word)) { semanticClassOdds = 1 - dictOddsWordWeights.GetCount(word); } scoreslist.SetCount(ConstantsAndVariables.ScorePhraseMeasures.Semanticodds, semanticClassOdds); } if (constVars.usePatternEvalGoogleNgram) { double gscore = 0; if (googleNgramNormScores.ContainsKey(word)) { gscore = 1 - googleNgramNormScores.GetCount(word); } scoreslist.SetCount(ConstantsAndVariables.ScorePhraseMeasures.Googlengram, gscore); } if (constVars.usePatternEvalDomainNgram) { double domainscore; if (domainNgramNormScores.ContainsKey(word)) { domainscore = 1 - domainNgramNormScores.GetCount(word); } else { domainscore = 1 - scorePhrases.phraseScorer.GetPhraseWeightFromWords(domainNgramNormScores, word, scorePhrases.phraseScorer.OOVDomainNgramScore); } scoreslist.SetCount(ConstantsAndVariables.ScorePhraseMeasures.Domainngram, domainscore); } if (constVars.usePatternEvalWordClass) { double externalFeatureWt = externalWtsDefault; if (externalFeatWtsNormalized.ContainsKey(word)) { externalFeatureWt = 1 - externalFeatWtsNormalized.GetCount(word); } scoreslist.SetCount(ConstantsAndVariables.ScorePhraseMeasures.Distsim, externalFeatureWt); } if (constVars.usePatternEvalEditDistOther) { System.Diagnostics.Debug.Assert(editDistanceFromOtherSemanticBinaryScores.ContainsKey(word), "How come no edit distance info for word " + word + string.Empty); scoreslist.SetCount(ConstantsAndVariables.ScorePhraseMeasures.Editdistother, editDistanceFromOtherSemanticBinaryScores.GetCount(word)); } if (constVars.usePatternEvalEditDistSame) { scoreslist.SetCount(ConstantsAndVariables.ScorePhraseMeasures.Editdistsame, editDistanceFromAlreadyExtractedBinaryScores.GetCount(word)); } // taking average score = Counters.Mean(scoreslist); phInPatScores.SetCounter(word, scoreslist); } cachedScoresForThisIter.SetCount(word, score); } } else { if ((patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.Logreg) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.LOGREGlogP)) && scorePhrasesInPatSelection) { score = 1 - classifierScores.GetCount(word); } } // score = 1 - scorePhrases.scoreUsingClassifer(classifier, // e.getKey(), label, true, null, null, dictOddsWordWeights); // throw new RuntimeException("not implemented yet"); if (useFreqPhraseExtractedByPat) { score = score * scoringFunction.ApplyAsDouble(new Pair <E, CandidatePhrase>(en.Key, word)); } if (constVars.sqrtPatScore) { patterns.IncrementCount(en.Key, Math.Sqrt(score)); } else { patterns.IncrementCount(en.Key, score); } } } return(patterns); }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> public override ICounter <E> Score() { ICounter <CandidatePhrase> externalWordWeightsNormalized = null; if (constVars.dictOddsWeights.Contains(label)) { externalWordWeightsNormalized = GetPatternsFromDataMultiClass.NormalizeSoftMaxMinMaxScores(constVars.dictOddsWeights[label], true, true, false); } ICounter <E> currentPatternWeights4Label = new ClassicCounter <E>(); bool useFreqPhraseExtractedByPat = false; if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.SqrtAllRatio)) { useFreqPhraseExtractedByPat = true; } IToDoubleFunction <Pair <E, CandidatePhrase> > numeratorScore = null; ICounter <E> numeratorPatWt = this.Convert2OneDim(label, numeratorScore, allCandidatePhrases, patternsandWords4Label, constVars.sqrtPatScore, false, null, useFreqPhraseExtractedByPat); ICounter <E> denominatorPatWt = null; IToDoubleFunction <Pair <E, CandidatePhrase> > denoScore; if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PosNegUnlabOdds)) { denoScore = null; denominatorPatWt = this.Convert2OneDim(label, denoScore, allCandidatePhrases, patternsandWords4Label, constVars.sqrtPatScore, false, externalWordWeightsNormalized, useFreqPhraseExtractedByPat); } else { if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.RatioAll)) { denoScore = null; denominatorPatWt = this.Convert2OneDim(label, denoScore, allCandidatePhrases, patternsandWords4Label, constVars.sqrtPatScore, false, externalWordWeightsNormalized, useFreqPhraseExtractedByPat); } else { if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PosNegOdds)) { denoScore = null; denominatorPatWt = this.Convert2OneDim(label, denoScore, allCandidatePhrases, patternsandWords4Label, constVars.sqrtPatScore, false, externalWordWeightsNormalized, useFreqPhraseExtractedByPat); } else { if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPat) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPatLogP) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring. Logreg) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.LOGREGlogP)) { denoScore = null; denominatorPatWt = this.Convert2OneDim(label, denoScore, allCandidatePhrases, patternsandWords4Label, constVars.sqrtPatScore, true, externalWordWeightsNormalized, useFreqPhraseExtractedByPat); } else { if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.SqrtAllRatio)) { denoScore = null; denominatorPatWt = this.Convert2OneDim(label, denoScore, allCandidatePhrases, patternsandWords4Label, true, false, externalWordWeightsNormalized, useFreqPhraseExtractedByPat); } else { throw new Exception("Cannot understand patterns scoring"); } } } } } currentPatternWeights4Label = Counters.DivisionNonNaN(numeratorPatWt, denominatorPatWt); //Multiplying by logP if (patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.PhEvalInPatLogP) || patternScoring.Equals(GetPatternsFromDataMultiClass.PatternScoring.LOGREGlogP)) { ICounter <E> logpos_i = new ClassicCounter <E>(); foreach (KeyValuePair <E, ClassicCounter <CandidatePhrase> > en in patternsandWords4Label.EntrySet()) { logpos_i.SetCount(en.Key, Math.Log(en.Value.Size())); } Counters.MultiplyInPlace(currentPatternWeights4Label, logpos_i); } Counters.RetainNonZeros(currentPatternWeights4Label); return(currentPatternWeights4Label); }
public EvalFunction(IToDoubleFunction <Node <S, A> > h) { this.h = h; }
/** * Constructs a simulated annealing search from the specified heuristic * function and scheduler. * * @param h * a heuristic function * @param scheduler * a mapping from time to "temperature" */ public SimulatedAnnealingSearch(IToDoubleFunction <Node <S, A> > h, Scheduler scheduler) : this(h, scheduler, new NodeExpander <S, A>()) { }
public BestFirstSearchComparer(IToDoubleFunction <Node <S, A> > evalFn) { this.evalFn = evalFn; }
public HillClimbingSearch(IToDoubleFunction <Node <S, A> > h, NodeExpander <S, A> nodeExpander) { this.h = h; this.nodeExpander = nodeExpander; nodeExpander.addNodeListener((node) => metrics.incrementInt(METRIC_NODES_EXPANDED)); }
public virtual IList <Match <K, V> > Segment <_T0>(IList <K> list, IToDoubleFunction <_T0> scoreFunc) { return(Segment(list, 0, list.Count, scoreFunc)); }
public virtual IList <Match <K, V> > GetNonOverlapping <_T0>(IList <Match <K, V> > allMatches, IToDoubleFunction <_T0> scoreFunc) { return(IntervalTree.GetNonOverlappingMaxScore(allMatches, scoreFunc)); }
/// <summary>Given a sequence to search through (e.g.</summary> /// <remarks> /// Given a sequence to search through (e.g. piece of text would be a sequence of words), /// finds all non-overlapping matching sub-sequences that matches entries in the trie while attempting to maximize the scoreFunc. /// </remarks> /// <param name="list">Sequence to search through</param> /// <param name="start">start index to start search at</param> /// <param name="end">end index (exclusive) to end search at</param> /// <param name="scoreFunc">Scoring function indicating how good the match is</param> /// <returns>List of matches sorted by start position</returns> public virtual IList <Match <K, V> > FindNonOverlapping <_T0>(IList <K> list, int start, int end, IToDoubleFunction <_T0> scoreFunc) { IList <Match <K, V> > allMatches = FindAllMatches(list, start, end); return(GetNonOverlapping(allMatches, scoreFunc)); }
/// <summary> /// Segment a sequence into sequence of sub-sequences by attempting to maximize the total score /// Non-matched parts will be included as a match with a null value. /// </summary> /// <param name="list">Sequence to search through</param> /// <param name="start">start index to start search at</param> /// <param name="end">end index (exclusive) to end search at</param> /// <param name="scoreFunc">Scoring function indicating how good the match is</param> /// <returns>List of segments (as matches) sorted by start position</returns> public virtual IList <Match <K, V> > Segment <_T0>(IList <K> list, int start, int end, IToDoubleFunction <_T0> scoreFunc) { IList <Match <K, V> > nonOverlapping = FindNonOverlapping(list, start, end, scoreFunc); IList <Match <K, V> > segments = new List <Match <K, V> >(nonOverlapping.Count); int last = 0; foreach (Match <K, V> match in nonOverlapping) { if (match.begin > last) { // Create empty match and add to segments Match <K, V> empty = new Match <K, V>(list.SubList(last, match.begin), null, last, match.begin); segments.Add(empty); } segments.Add(match); last = match.end; } if (list.Count > last) { Match <K, V> empty = new Match <K, V>(list.SubList(last, list.Count), null, last, list.Count); segments.Add(empty); } return(segments); }
/// <summary> /// This method will cross validate on the given data and number of folds /// to find the optimal C. /// </summary> /// <remarks> /// This method will cross validate on the given data and number of folds /// to find the optimal C. The scorer is how you determine what to /// optimize for (F-score, accuracy, etc). The C is then saved, so that /// if you train a classifier after calling this method, that C will be used. /// </remarks> public virtual void CrossValidateSetC(GeneralDataset <L, F> dataset, int numFolds, IScorer <L> scorer, ILineSearcher minimizer) { System.Console.Out.WriteLine("in Cross Validate"); useAlphaFile = true; bool oldUseSigmoid = useSigmoid; useSigmoid = false; CrossValidator <L, F> crossValidator = new CrossValidator <L, F>(dataset, numFolds); IToDoubleFunction <Triple <GeneralDataset <L, F>, GeneralDataset <L, F>, CrossValidator.SavedState> > score = null; //train(trainSet,true,true); IDoubleUnaryOperator negativeScorer = null; C = minimizer.Minimize(negativeScorer); useAlphaFile = false; useSigmoid = oldUseSigmoid; }
/** * Creates a search instance. * * @param strategy * search strategy. See static constants. * @param qSearchImpl * queue search implementation: e.g. {@link #TREE_SEARCH}, {@link #GRAPH_SEARCH} * */ public ISearchForActions <S, A> createSearch <S, A>(int strategy, int qSearchImpl, IToDoubleFunction <Node <S, A> > h) { QueueSearch <S, A> qs = null; ISearchForActions <S, A> result = null; switch (qSearchImpl) { case TREE_SEARCH: qs = new TreeSearch <S, A>(); break; case GRAPH_SEARCH: qs = new GraphSearch <S, A>(); break; case GRAPH_SEARCH_RED_FRONTIER: qs = new GraphSearchReducedFrontier <S, A>(); break; case GRAPH_SEARCH_BFS: qs = new GraphSearchBFS <S, A>(); break; case BIDIRECTIONAL_SEARCH: qs = new BidirectionalSearch <S, A>(); break; } switch (strategy) { case DF_SEARCH: result = new DepthFirstSearch <S, A>(qs); break; case BF_SEARCH: result = new BreadthFirstSearch <S, A>(qs); break; case ID_SEARCH: result = new IterativeDeepeningSearch <S, A>(); break; case UC_SEARCH: result = new UniformCostSearch <S, A>(qs); break; case GBF_SEARCH: result = new GreedyBestFirstSearch <S, A>(qs, h); break; case ASTAR_SEARCH: result = new AStarSearch <S, A>(qs, h); break; case RBF_SEARCH: result = new RecursiveBestFirstSearch <S, A>(new AStarSearch <S, A> .EvalFunction(h)); break; case RBF_AL_SEARCH: result = new RecursiveBestFirstSearch <S, A>(new AStarSearch <S, A> .EvalFunction(h), true); break; case HILL_SEARCH: result = new HillClimbingSearch <S, A>(h); break; } return(result); }
public static IList <T> GetNonOverlappingMaxScore <T, E, _T2, _T3>(IList <_T2> items, IToDoubleFunction <_T3> scoreFunc) where T : IHasInterval <E> where E : IComparable <E> where _T2 : T { IFunction <T, Interval <E> > toIntervalFunc = null; return(GetNonOverlappingMaxScore(items, toIntervalFunc, scoreFunc)); }
/** * Constructs a LRTA* agent with the specified search problem, percept to * state function, and heuristic function. * * @param problem * an online search problem for this agent to solve. * @param ptsFn * a function which returns the problem state associated with a * given Percept. * @param h * heuristic function <em>h(n)</em>, which estimates the cost of * the cheapest path from the state at node <em>n</em> to a goal * state. */ public LRTAStarAgent(IOnlineSearchProblem <S, A> problem, Function <IPercept, S> ptsFn, IToDoubleFunction <S> h) { setProblem(problem); setPerceptToStateFunction(ptsFn); setHeuristicFunction(h); }
/** * Constructs a hill-climbing search from the specified heuristic function. * * @param h a heuristic function */ public HillClimbingSearch(IToDoubleFunction <Node <S, A> > h) : this(h, new NodeExpander <S, A>()) { }
public virtual void setHeuristicFunction(IToDoubleFunction <Node <S, A> > h) { this.h = h; }
/** * Constructor which allows to enable the loop avoidance strategy. */ public RecursiveBestFirstSearch(IToDoubleFunction <Node <S, A> > evalFn, bool avoidLoops) : this(evalFn, avoidLoops, new NodeExpander <S, A>()) { }
/** * Constructs a best first search from a specified search problem and * evaluation function. * * @param impl * a search space exploration strategy. * @param evalFn * an evaluation function, which returns a number purporting to * describe the desirability (or lack thereof) of expanding a * node. */ public BestFirstSearch(QueueSearch <S, A> impl, IToDoubleFunction <Node <S, A> > evalFn) : base(impl, CollectionFactory.CreatePriorityQueue <Node <S, A> >(new BestFirstSearchComparer(evalFn))) { this.evalFn = evalFn; }
public static IList <T> GetNonOverlappingMaxScore <T, E, _T2, _T3, _T4>(IList <_T2> items, IFunction <_T3> toIntervalFunc, IToDoubleFunction <_T4> scoreFunc) where E : IComparable <E> where _T2 : T { if (items.Count > 1) { IDictionary <E, IntervalTree.PartialScoredList <T, E> > bestNonOverlapping = new SortedDictionary <E, IntervalTree.PartialScoredList <T, E> >(); foreach (T item in items) { Interval <E> itemInterval = toIntervalFunc.Apply(item); E mBegin = itemInterval.GetBegin(); E mEnd = itemInterval.GetEnd(); IntervalTree.PartialScoredList <T, E> bestk = bestNonOverlapping[mEnd]; double itemScore = scoreFunc.ApplyAsDouble(item); if (bestk == null) { bestk = new IntervalTree.PartialScoredList <T, E>(); bestk.size = 1; bestk.score = itemScore; bestk.@object = item; bestNonOverlapping[mEnd] = bestk; } // Assumes map is ordered foreach (E j in bestNonOverlapping.Keys) { if (j.CompareTo(mBegin) > 0) { break; } // Consider adding this match into the bestNonOverlapping strand at j IntervalTree.PartialScoredList <T, E> bestj = bestNonOverlapping[j]; double withMatchScore = bestj.score + itemScore; bool better = false; if (withMatchScore > bestk.score) { better = true; } else { if (withMatchScore == bestk.score) { if (bestj.size + 1 < bestk.size) { better = true; } } } if (better) { bestk.size = bestj.size + 1; bestk.score = withMatchScore; bestk.@object = item; bestk.lastMatchKey = j; } } } IntervalTree.PartialScoredList <T, E> best = null; foreach (IntervalTree.PartialScoredList <T, E> v in bestNonOverlapping.Values) { if (best == null || v.score > best.score) { best = v; } } IList <T> nonOverlapping = new List <T>(best.size); IntervalTree.PartialScoredList <T, E> prev = best; while (prev != null) { if (prev.@object != null) { nonOverlapping.Add(prev.@object); } if (prev.lastMatchKey != null) { prev = bestNonOverlapping[prev.lastMatchKey]; } else { prev = null; } } Java.Util.Collections.Reverse(nonOverlapping); return(nonOverlapping); } else { IList <T> nonOverlapping = new List <T>(items); return(nonOverlapping); } }
/** * Constructs a greedy best-first search from a specified search space * exploration strategy and a heuristic function. * * @param impl * a search space exploration strategy (e.g. TreeSearch, * GraphSearch). * @param h * a heuristic function <em>h(n)</em>, which estimates the * cheapest path from the state at node <em>n</em> to a goal * state. */ public GreedyBestFirstSearch(QueueSearch <S, A> impl, IToDoubleFunction <Node <S, A> > h) : base(impl, new EvalFunction(h)) { }
public BoundedCostOrderedMap(IToDoubleFunction <V> costFunction, int maxSize, double maxCost) { this.costFunction = costFunction; this.maxSize = maxSize; this.maxCost = maxCost; }
public RecursiveBestFirstSearch(IToDoubleFunction <Node <S, A> > evalFn) : this(evalFn, false) { }
/** * Constructs a simulated annealing search from the specified heuristic * function and a default scheduler. * * @param h * a heuristic function */ public SimulatedAnnealingSearch(IToDoubleFunction <Node <S, A> > h) : this(h, new Scheduler()) { }